Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/ldpd/l2vpn.c	Lines:	0	252	0.0 %
Date:	2017-11-07	Branches:	0	164	0.0 %


/*	$OpenBSD: l2vpn.c,v 1.24 2017/03/04 00:21:48 renato Exp $ */

/*
 * Copyright (c) 2015 Renato Westphal <renato@openbsd.org>
 * Copyright (c) 2009 Michele Marchetto <michele@openbsd.org>
 * Copyright (c) 2005 Claudio Jeker <claudio@openbsd.org>
 * Copyright (c) 2004, 2005, 2008 Esben Norby <norby@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

#include "ldpd.h"
#include "ldpe.h"
#include "lde.h"
#include "log.h"

static void	 l2vpn_pw_fec(struct l2vpn_pw *, struct fec *);

struct l2vpn *
l2vpn_new(const char *name)
{
	struct l2vpn	*l2vpn;

	if ((l2vpn = calloc(1, sizeof(*l2vpn))) == NULL)
		fatal("l2vpn_new: calloc");

	strlcpy(l2vpn->name, name, sizeof(l2vpn->name));

	/* set default values */
	l2vpn->mtu = DEFAULT_L2VPN_MTU;
	l2vpn->pw_type = DEFAULT_PW_TYPE;

	LIST_INIT(&l2vpn->if_list);
	LIST_INIT(&l2vpn->pw_list);

	return (l2vpn);
}

struct l2vpn *
l2vpn_find(struct ldpd_conf *xconf, const char *name)
{
	struct l2vpn	*l2vpn;

	LIST_FOREACH(l2vpn, &xconf->l2vpn_list, entry)
		if (strcmp(l2vpn->name, name) == 0)
			return (l2vpn);

	return (NULL);
}

void
l2vpn_del(struct l2vpn *l2vpn)
{
	struct l2vpn_if		*lif;
	struct l2vpn_pw		*pw;

	while ((lif = LIST_FIRST(&l2vpn->if_list)) != NULL) {
		LIST_REMOVE(lif, entry);
		free(lif);
	}
	while ((pw = LIST_FIRST(&l2vpn->pw_list)) != NULL) {
		LIST_REMOVE(pw, entry);
		free(pw);
	}

	free(l2vpn);
}

void
l2vpn_init(struct l2vpn *l2vpn)
{
	struct l2vpn_pw	*pw;

	LIST_FOREACH(pw, &l2vpn->pw_list, entry)
		l2vpn_pw_init(pw);
}

void
l2vpn_exit(struct l2vpn *l2vpn)
{
	struct l2vpn_pw		*pw;

	LIST_FOREACH(pw, &l2vpn->pw_list, entry)
		l2vpn_pw_exit(pw);
}

struct l2vpn_if *
l2vpn_if_new(struct l2vpn *l2vpn, struct kif *kif)
{
	struct l2vpn_if	*lif;

	if ((lif = calloc(1, sizeof(*lif))) == NULL)
		fatal("l2vpn_if_new: calloc");

	lif->l2vpn = l2vpn;
	strlcpy(lif->ifname, kif->ifname, sizeof(lif->ifname));
	lif->ifindex = kif->ifindex;
	lif->flags = kif->flags;
	lif->linkstate = kif->link_state;

	return (lif);
}

struct l2vpn_if *
l2vpn_if_find(struct l2vpn *l2vpn, unsigned int ifindex)
{
	struct l2vpn_if	*lif;

	LIST_FOREACH(lif, &l2vpn->if_list, entry)
		if (lif->ifindex == ifindex)
			return (lif);

	return (NULL);
}

void
l2vpn_if_update(struct l2vpn_if *lif)
{
	struct l2vpn	*l2vpn = lif->l2vpn;
	struct l2vpn_pw	*pw;
	struct map	 fec;
	struct nbr	*nbr;

	if ((lif->flags & IFF_UP) && LINK_STATE_IS_UP(lif->linkstate))
		return;

	LIST_FOREACH(pw, &l2vpn->pw_list, entry) {
		nbr = nbr_find_ldpid(pw->lsr_id.s_addr);
		if (nbr == NULL)
			continue;

		memset(&fec, 0, sizeof(fec));
		fec.type = MAP_TYPE_PWID;
		fec.fec.pwid.type = l2vpn->pw_type;
		fec.fec.pwid.group_id = 0;
		fec.flags |= F_MAP_PW_ID;
		fec.fec.pwid.pwid = pw->pwid;

		send_mac_withdrawal(nbr, &fec, lif->mac);
	}
}

struct l2vpn_pw *
l2vpn_pw_new(struct l2vpn *l2vpn, struct kif *kif)
{
	struct l2vpn_pw	*pw;

	if ((pw = calloc(1, sizeof(*pw))) == NULL)
		fatal("l2vpn_pw_new: calloc");

	pw->l2vpn = l2vpn;
	strlcpy(pw->ifname, kif->ifname, sizeof(pw->ifname));
	pw->ifindex = kif->ifindex;

	return (pw);
}

struct l2vpn_pw *
l2vpn_pw_find(struct l2vpn *l2vpn, unsigned int ifindex)
{
	struct l2vpn_pw	*pw;

	LIST_FOREACH(pw, &l2vpn->pw_list, entry)
		if (pw->ifindex == ifindex)
			return (pw);

	return (NULL);
}

void
l2vpn_pw_init(struct l2vpn_pw *pw)
{
	struct fec	 fec;

	l2vpn_pw_reset(pw);

	l2vpn_pw_fec(pw, &fec);
	lde_kernel_insert(&fec, AF_INET, (union ldpd_addr*)&pw->lsr_id, 0,
	    0, (void *)pw);
}

void
l2vpn_pw_exit(struct l2vpn_pw *pw)
{
	struct fec	 fec;

	l2vpn_pw_fec(pw, &fec);
	lde_kernel_remove(&fec, AF_INET, (union ldpd_addr*)&pw->lsr_id, 0);
}

static void
l2vpn_pw_fec(struct l2vpn_pw *pw, struct fec *fec)
{
	memset(fec, 0, sizeof(*fec));
	fec->type = FEC_TYPE_PWID;
	fec->u.pwid.type = pw->l2vpn->pw_type;
	fec->u.pwid.pwid = pw->pwid;
	fec->u.pwid.lsr_id = pw->lsr_id;
}

void
l2vpn_pw_reset(struct l2vpn_pw *pw)
{
	pw->remote_group = 0;
	pw->remote_mtu = 0;
	pw->remote_status = 0;

	if (pw->flags & F_PW_CWORD_CONF)
		pw->flags |= F_PW_CWORD;
	else
		pw->flags &= ~F_PW_CWORD;

	if (pw->flags & F_PW_STATUSTLV_CONF)
		pw->flags |= F_PW_STATUSTLV;
	else
		pw->flags &= ~F_PW_STATUSTLV;
}

int
l2vpn_pw_ok(struct l2vpn_pw *pw, struct fec_nh *fnh)
{
	struct fec		 fec;
	struct fec_node		*fn;

	/* check for a remote label */
	if (fnh->remote_label == NO_LABEL)
		return (0);

	/* MTUs must match */
	if (pw->l2vpn->mtu != pw->remote_mtu)
		return (0);

	/* check pw status if applicable */
	if ((pw->flags & F_PW_STATUSTLV) &&
	    pw->remote_status != PW_FORWARDING)
		return (0);

	/* check for a working lsp to the nexthop */
	memset(&fec, 0, sizeof(fec));
	switch (pw->af) {
	case AF_INET:
		fec.type = FEC_TYPE_IPV4;
		fec.u.ipv4.prefix = pw->addr.v4;
		fec.u.ipv4.prefixlen = 32;
		break;
	case AF_INET6:
		fec.type = FEC_TYPE_IPV6;
		fec.u.ipv6.prefix = pw->addr.v6;
		fec.u.ipv6.prefixlen = 128;
		break;
	default:
		fatalx("l2vpn_pw_ok: unknown af");
	}

	fn = (struct fec_node *)fec_find(&ft, &fec);
	if (fn == NULL || fn->local_label == NO_LABEL)
		return (0);
	/*
	 * Need to ensure that there's a label binding for all nexthops.
	 * Otherwise, ECMP for this route could render the pseudowire unusable.
	 */
	LIST_FOREACH(fnh, &fn->nexthops, entry)
		if (fnh->remote_label == NO_LABEL)
			return (0);

	return (1);
}

int
l2vpn_pw_negotiate(struct lde_nbr *ln, struct fec_node *fn, struct map *map)
{
	struct l2vpn_pw		*pw;
	struct status_tlv	 st;

	/* NOTE: thanks martini & friends for all this mess */

	pw = (struct l2vpn_pw *) fn->data;
	if (pw == NULL)
		/*
		 * pseudowire not configured, return and record
		 * the mapping later
		 */
		return (0);

	/* RFC4447 - Section 6.2: control word negotiation */
	if (fec_find(&ln->sent_map, &fn->fec)) {
		if ((map->flags & F_MAP_PW_CWORD) &&
		    !(pw->flags & F_PW_CWORD_CONF)) {
			/* ignore the received label mapping */
			return (1);
		} else if (!(map->flags & F_MAP_PW_CWORD) &&
		    (pw->flags & F_PW_CWORD_CONF)) {
			/* append a "Wrong C-bit" status code */
			st.status_code = S_WRONG_CBIT;
			st.msg_id = map->msg_id;
			st.msg_type = htons(MSG_TYPE_LABELMAPPING);
			lde_send_labelwithdraw(ln, fn, NULL, &st);

			pw->flags &= ~F_PW_CWORD;
			lde_send_labelmapping(ln, fn, 1);
		}
	} else if (map->flags & F_MAP_PW_CWORD) {
		if (pw->flags & F_PW_CWORD_CONF)
			pw->flags |= F_PW_CWORD;
		else
			/* act as if no label mapping had been received */
			return (1);
	} else
		pw->flags &= ~F_PW_CWORD;

	/* RFC4447 - Section 5.4.3: pseudowire status negotiation */
	if (fec_find(&ln->recv_map, &fn->fec) == NULL &&
	    !(map->flags & F_MAP_PW_STATUS))
		pw->flags &= ~F_PW_STATUSTLV;

	return (0);
}

void
l2vpn_send_pw_status(struct lde_nbr *ln, uint32_t status, struct fec *fec)
{
	struct notify_msg	 nm;

	memset(&nm, 0, sizeof(nm));
	nm.status_code = S_PW_STATUS;
	nm.pw_status = status;
	nm.flags |= F_NOTIF_PW_STATUS;
	lde_fec2map(fec, &nm.fec);
	nm.flags |= F_NOTIF_FEC;

	lde_imsg_compose_ldpe(IMSG_NOTIFICATION_SEND, ln->peerid, 0, &nm,
	    sizeof(nm));
}

void
l2vpn_send_pw_status_wcard(struct lde_nbr *ln, uint32_t status,
    uint16_t pw_type, uint32_t group_id)
{
	struct notify_msg	 nm;

	memset(&nm, 0, sizeof(nm));
	nm.status_code = S_PW_STATUS;
	nm.pw_status = status;
	nm.flags |= F_NOTIF_PW_STATUS;
	nm.fec.type = MAP_TYPE_PWID;
	nm.fec.fec.pwid.type = pw_type;
	nm.fec.fec.pwid.group_id = group_id;
	nm.flags |= F_NOTIF_FEC;

	lde_imsg_compose_ldpe(IMSG_NOTIFICATION_SEND, ln->peerid, 0, &nm,
	    sizeof(nm));
}

void
l2vpn_recv_pw_status(struct lde_nbr *ln, struct notify_msg *nm)
{
	struct fec		 fec;
	struct fec_node		*fn;
	struct fec_nh		*fnh;
	struct l2vpn_pw		*pw;

	if (nm->fec.type == MAP_TYPE_TYPED_WCARD ||
	    !(nm->fec.flags & F_MAP_PW_ID)) {
		l2vpn_recv_pw_status_wcard(ln, nm);
		return;
	}

	lde_map2fec(&nm->fec, ln->id, &fec);
	fn = (struct fec_node *)fec_find(&ft, &fec);
	if (fn == NULL)
		/* unknown fec */
		return;

	pw = (struct l2vpn_pw *) fn->data;
	if (pw == NULL)
		return;

	fnh = fec_nh_find(fn, AF_INET, (union ldpd_addr *)&ln->id, 0);
	if (fnh == NULL)
		return;

	/* remote status didn't change */
	if (pw->remote_status == nm->pw_status)
		return;
	pw->remote_status = nm->pw_status;

	if (l2vpn_pw_ok(pw, fnh))
		lde_send_change_klabel(fn, fnh);
	else
		lde_send_delete_klabel(fn, fnh);
}

/* RFC4447 PWid group wildcard */
void
l2vpn_recv_pw_status_wcard(struct lde_nbr *ln, struct notify_msg *nm)
{
	struct fec		*f;
	struct fec_node		*fn;
	struct fec_nh		*fnh;
	struct l2vpn_pw		*pw;
	struct map		*wcard = &nm->fec;

	RB_FOREACH(f, fec_tree, &ft) {
		fn = (struct fec_node *)f;
		if (fn->fec.type != FEC_TYPE_PWID)
			continue;

		pw = (struct l2vpn_pw *) fn->data;
		if (pw == NULL)
			continue;

		switch (wcard->type) {
		case MAP_TYPE_TYPED_WCARD:
			if (wcard->fec.twcard.u.pw_type != PW_TYPE_WILDCARD &&
			    wcard->fec.twcard.u.pw_type != fn->fec.u.pwid.type)
				continue;
			break;
		case MAP_TYPE_PWID:
			if (wcard->fec.pwid.type != fn->fec.u.pwid.type)
				continue;
			if (wcard->fec.pwid.group_id != pw->remote_group)
				continue;
			break;
		}

		fnh = fec_nh_find(fn, AF_INET, (union ldpd_addr *)&ln->id, 0);
		if (fnh == NULL)
			continue;

		/* remote status didn't change */
		if (pw->remote_status == nm->pw_status)
			continue;
		pw->remote_status = nm->pw_status;

		if (l2vpn_pw_ok(pw, fnh))
			lde_send_change_klabel(fn, fnh);
		else
			lde_send_delete_klabel(fn, fnh);
	}
}

void
l2vpn_sync_pws(int af, union ldpd_addr *addr)
{
	struct l2vpn		*l2vpn;
	struct l2vpn_pw		*pw;
	struct fec		 fec;
	struct fec_node		*fn;
	struct fec_nh		*fnh;

	LIST_FOREACH(l2vpn, &ldeconf->l2vpn_list, entry) {
		LIST_FOREACH(pw, &l2vpn->pw_list, entry) {
			if (af != pw->af || ldp_addrcmp(af, &pw->addr, addr))
				continue;

			l2vpn_pw_fec(pw, &fec);
			fn = (struct fec_node *)fec_find(&ft, &fec);
			if (fn == NULL)
				continue;
			fnh = fec_nh_find(fn, AF_INET, (union ldpd_addr *)
			    &pw->lsr_id, 0);
			if (fnh == NULL)
				continue;

			if (l2vpn_pw_ok(pw, fnh))
				lde_send_change_klabel(fn, fnh);
			else
				lde_send_delete_klabel(fn, fnh);
		}
	}
}

void
l2vpn_pw_ctl(pid_t pid)
{
	struct l2vpn		*l2vpn;
	struct l2vpn_pw		*pw;
	static struct ctl_pw	 pwctl;

	LIST_FOREACH(l2vpn, &ldeconf->l2vpn_list, entry)
		LIST_FOREACH(pw, &l2vpn->pw_list, entry) {
			memset(&pwctl, 0, sizeof(pwctl));
			strlcpy(pwctl.ifname, pw->ifname,
			    sizeof(pwctl.ifname));
			pwctl.pwid = pw->pwid;
			pwctl.lsr_id = pw->lsr_id;
			pwctl.status = pw->flags & F_PW_STATUS_UP;

			lde_imsg_compose_ldpe(IMSG_CTL_SHOW_L2VPN_PW, 0,
			    pid, &pwctl, sizeof(pwctl));
		}
}

void
l2vpn_binding_ctl(pid_t pid)
{
	struct fec		*f;
	struct fec_node		*fn;
	struct lde_map		*me;
	struct l2vpn_pw		*pw;
	static struct ctl_pw	 pwctl;

	RB_FOREACH(f, fec_tree, &ft) {
		if (f->type != FEC_TYPE_PWID)
			continue;

		fn = (struct fec_node *)f;
		if (fn->local_label == NO_LABEL &&
		    LIST_EMPTY(&fn->downstream))
			continue;

		memset(&pwctl, 0, sizeof(pwctl));
		pwctl.type = f->u.pwid.type;
		pwctl.pwid = f->u.pwid.pwid;
		pwctl.lsr_id = f->u.pwid.lsr_id;

		pw = (struct l2vpn_pw *) fn->data;
		if (pw) {
			pwctl.local_label = fn->local_label;
			pwctl.local_gid = 0;
			pwctl.local_ifmtu = pw->l2vpn->mtu;
		} else
			pwctl.local_label = NO_LABEL;

		LIST_FOREACH(me, &fn->downstream, entry)
			if (f->u.pwid.lsr_id.s_addr == me->nexthop->id.s_addr)
				break;

		if (me) {
			pwctl.remote_label = me->map.label;
			pwctl.remote_gid = me->map.fec.pwid.group_id;
			if (me->map.flags & F_MAP_PW_IFMTU)
				pwctl.remote_ifmtu = me->map.fec.pwid.ifmtu;

			lde_imsg_compose_ldpe(IMSG_CTL_SHOW_L2VPN_BINDING,
			    0, pid, &pwctl, sizeof(pwctl));
		} else if (pw) {
			pwctl.remote_label = NO_LABEL;

			lde_imsg_compose_ldpe(IMSG_CTL_SHOW_L2VPN_BINDING,
			    0, pid, &pwctl, sizeof(pwctl));
		}
	}
}

/* ldpe */

void
ldpe_l2vpn_init(struct l2vpn *l2vpn)
{
	struct l2vpn_pw		*pw;

	LIST_FOREACH(pw, &l2vpn->pw_list, entry)
		ldpe_l2vpn_pw_init(pw);
}

void
ldpe_l2vpn_exit(struct l2vpn *l2vpn)
{
	struct l2vpn_pw		*pw;

	LIST_FOREACH(pw, &l2vpn->pw_list, entry)
		ldpe_l2vpn_pw_exit(pw);
}

void
ldpe_l2vpn_pw_init(struct l2vpn_pw *pw)
{
	struct tnbr		*tnbr;

	tnbr = tnbr_find(leconf, pw->af, &pw->addr);
	if (tnbr == NULL) {
		tnbr = tnbr_new(leconf, pw->af, &pw->addr);
		tnbr_update(tnbr);
		LIST_INSERT_HEAD(&leconf->tnbr_list, tnbr, entry);
	}

	tnbr->pw_count++;
}

void
ldpe_l2vpn_pw_exit(struct l2vpn_pw *pw)
{
	struct tnbr		*tnbr;

	tnbr = tnbr_find(leconf, pw->af, &pw->addr);
	if (tnbr) {
		tnbr->pw_count--;
		tnbr_check(tnbr);
	}
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: l2vpn.c,v 1.24 2017/03/04 00:21:48 renato Exp $ */
2
3			/*
4			* Copyright (c) 2015 Renato Westphal <renato@openbsd.org>
5			* Copyright (c) 2009 Michele Marchetto <michele@openbsd.org>
6			* Copyright (c) 2005 Claudio Jeker <claudio@openbsd.org>
7			* Copyright (c) 2004, 2005, 2008 Esben Norby <norby@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 <sys/types.h>
23			#include <stdlib.h>
24			#include <string.h>
25			#include <limits.h>
26
27			#include "ldpd.h"
28			#include "ldpe.h"
29			#include "lde.h"
30			#include "log.h"
31
32			static void l2vpn_pw_fec(struct l2vpn_pw , struct fec );
33
34			struct l2vpn *
35			l2vpn_new(const char *name)
36			{
37			struct l2vpn *l2vpn;
38
39			if ((l2vpn = calloc(1, sizeof(*l2vpn))) == NULL)
40			fatal("l2vpn_new: calloc");
41
42			strlcpy(l2vpn->name, name, sizeof(l2vpn->name));
43
44			/* set default values */
45			l2vpn->mtu = DEFAULT_L2VPN_MTU;
46			l2vpn->pw_type = DEFAULT_PW_TYPE;
47
48			LIST_INIT(&l2vpn->if_list);
49			LIST_INIT(&l2vpn->pw_list);
50
51			return (l2vpn);
52			}
53
54			struct l2vpn *
55			l2vpn_find(struct ldpd_conf xconf, const char name)
56			{
57			struct l2vpn *l2vpn;
58
59			LIST_FOREACH(l2vpn, &xconf->l2vpn_list, entry)
60			if (strcmp(l2vpn->name, name) == 0)
61			return (l2vpn);
62
63			return (NULL);
64			}
65
66			void
67			l2vpn_del(struct l2vpn *l2vpn)
68			{
69			struct l2vpn_if *lif;
70			struct l2vpn_pw *pw;
71
72			while ((lif = LIST_FIRST(&l2vpn->if_list)) != NULL) {
73			LIST_REMOVE(lif, entry);
74			free(lif);
75			}
76			while ((pw = LIST_FIRST(&l2vpn->pw_list)) != NULL) {
77			LIST_REMOVE(pw, entry);
78			free(pw);
79			}
80
81			free(l2vpn);
82			}
83
84			void
85			l2vpn_init(struct l2vpn *l2vpn)
86			{
87			struct l2vpn_pw *pw;
88
89			LIST_FOREACH(pw, &l2vpn->pw_list, entry)
90			l2vpn_pw_init(pw);
91			}
92
93			void
94			l2vpn_exit(struct l2vpn *l2vpn)
95			{
96			struct l2vpn_pw *pw;
97
98			LIST_FOREACH(pw, &l2vpn->pw_list, entry)
99			l2vpn_pw_exit(pw);
100			}
101
102			struct l2vpn_if *
103			l2vpn_if_new(struct l2vpn l2vpn, struct kif kif)
104			{
105			struct l2vpn_if *lif;
106
107			if ((lif = calloc(1, sizeof(*lif))) == NULL)
108			fatal("l2vpn_if_new: calloc");
109
110			lif->l2vpn = l2vpn;
111			strlcpy(lif->ifname, kif->ifname, sizeof(lif->ifname));
112			lif->ifindex = kif->ifindex;
113			lif->flags = kif->flags;
114			lif->linkstate = kif->link_state;
115
116			return (lif);
117			}
118
119			struct l2vpn_if *
120			l2vpn_if_find(struct l2vpn *l2vpn, unsigned int ifindex)
121			{
122			struct l2vpn_if *lif;
123
124			LIST_FOREACH(lif, &l2vpn->if_list, entry)
125			if (lif->ifindex == ifindex)
126			return (lif);
127
128			return (NULL);
129			}
130
131			void
132			l2vpn_if_update(struct l2vpn_if *lif)
133			{
134			struct l2vpn *l2vpn = lif->l2vpn;
135			struct l2vpn_pw *pw;
136			struct map fec;
137			struct nbr *nbr;
138
139			if ((lif->flags & IFF_UP) && LINK_STATE_IS_UP(lif->linkstate))
140			return;
141
142			LIST_FOREACH(pw, &l2vpn->pw_list, entry) {
143			nbr = nbr_find_ldpid(pw->lsr_id.s_addr);
144			if (nbr == NULL)
145			continue;
146
147			memset(&fec, 0, sizeof(fec));
148			fec.type = MAP_TYPE_PWID;
149			fec.fec.pwid.type = l2vpn->pw_type;
150			fec.fec.pwid.group_id = 0;
151			fec.flags \|= F_MAP_PW_ID;
152			fec.fec.pwid.pwid = pw->pwid;
153
154			send_mac_withdrawal(nbr, &fec, lif->mac);
155			}
156			}
157
158			struct l2vpn_pw *
159			l2vpn_pw_new(struct l2vpn l2vpn, struct kif kif)
160			{
161			struct l2vpn_pw *pw;
162
163			if ((pw = calloc(1, sizeof(*pw))) == NULL)
164			fatal("l2vpn_pw_new: calloc");
165
166			pw->l2vpn = l2vpn;
167			strlcpy(pw->ifname, kif->ifname, sizeof(pw->ifname));
168			pw->ifindex = kif->ifindex;
169
170			return (pw);
171			}
172
173			struct l2vpn_pw *
174			l2vpn_pw_find(struct l2vpn *l2vpn, unsigned int ifindex)
175			{
176			struct l2vpn_pw *pw;
177
178			LIST_FOREACH(pw, &l2vpn->pw_list, entry)
179			if (pw->ifindex == ifindex)
180			return (pw);
181
182			return (NULL);
183			}
184
185			void
186			l2vpn_pw_init(struct l2vpn_pw *pw)
187			{
188			struct fec fec;
189
190			l2vpn_pw_reset(pw);
191
192			l2vpn_pw_fec(pw, &fec);
193			lde_kernel_insert(&fec, AF_INET, (union ldpd_addr*)&pw->lsr_id, 0,
194			0, (void *)pw);
195			}
196
197			void
198			l2vpn_pw_exit(struct l2vpn_pw *pw)
199			{
200			struct fec fec;
201
202			l2vpn_pw_fec(pw, &fec);
203			lde_kernel_remove(&fec, AF_INET, (union ldpd_addr*)&pw->lsr_id, 0);
204			}
205
206			static void
207			l2vpn_pw_fec(struct l2vpn_pw pw, struct fec fec)
208			{
209			memset(fec, 0, sizeof(*fec));
210			fec->type = FEC_TYPE_PWID;
211			fec->u.pwid.type = pw->l2vpn->pw_type;
212			fec->u.pwid.pwid = pw->pwid;
213			fec->u.pwid.lsr_id = pw->lsr_id;
214			}
215
216			void
217			l2vpn_pw_reset(struct l2vpn_pw *pw)
218			{
219			pw->remote_group = 0;
220			pw->remote_mtu = 0;
221			pw->remote_status = 0;
222
223			if (pw->flags & F_PW_CWORD_CONF)
224			pw->flags \|= F_PW_CWORD;
225			else
226			pw->flags &= ~F_PW_CWORD;
227
228			if (pw->flags & F_PW_STATUSTLV_CONF)
229			pw->flags \|= F_PW_STATUSTLV;
230			else
231			pw->flags &= ~F_PW_STATUSTLV;
232			}
233
234			int
235			l2vpn_pw_ok(struct l2vpn_pw pw, struct fec_nh fnh)
236			{
237			struct fec fec;
238			struct fec_node *fn;
239
240			/* check for a remote label */
241			if (fnh->remote_label == NO_LABEL)
242			return (0);
243
244			/* MTUs must match */
245			if (pw->l2vpn->mtu != pw->remote_mtu)
246			return (0);
247
248			/* check pw status if applicable */
249			if ((pw->flags & F_PW_STATUSTLV) &&
250			pw->remote_status != PW_FORWARDING)
251			return (0);
252
253			/* check for a working lsp to the nexthop */
254			memset(&fec, 0, sizeof(fec));
255			switch (pw->af) {
256			case AF_INET:
257			fec.type = FEC_TYPE_IPV4;
258			fec.u.ipv4.prefix = pw->addr.v4;
259			fec.u.ipv4.prefixlen = 32;
260			break;
261			case AF_INET6:
262			fec.type = FEC_TYPE_IPV6;
263			fec.u.ipv6.prefix = pw->addr.v6;
264			fec.u.ipv6.prefixlen = 128;
265			break;
266			default:
267			fatalx("l2vpn_pw_ok: unknown af");
268			}
269
270			fn = (struct fec_node *)fec_find(&ft, &fec);
271			if (fn == NULL \|\| fn->local_label == NO_LABEL)
272			return (0);
273			/*
274			* Need to ensure that there's a label binding for all nexthops.
275			* Otherwise, ECMP for this route could render the pseudowire unusable.
276			*/
277			LIST_FOREACH(fnh, &fn->nexthops, entry)
278			if (fnh->remote_label == NO_LABEL)
279			return (0);
280
281			return (1);
282			}
283
284			int
285			l2vpn_pw_negotiate(struct lde_nbr ln, struct fec_node fn, struct map *map)
286			{
287			struct l2vpn_pw *pw;
288			struct status_tlv st;
289
290			/* NOTE: thanks martini & friends for all this mess */
291
292			pw = (struct l2vpn_pw *) fn->data;
293			if (pw == NULL)
294			/*
295			* pseudowire not configured, return and record
296			* the mapping later
297			*/
298			return (0);
299
300			/* RFC4447 - Section 6.2: control word negotiation */
301			if (fec_find(&ln->sent_map, &fn->fec)) {
302			if ((map->flags & F_MAP_PW_CWORD) &&
303			!(pw->flags & F_PW_CWORD_CONF)) {
304			/* ignore the received label mapping */
305			return (1);
306			} else if (!(map->flags & F_MAP_PW_CWORD) &&
307			(pw->flags & F_PW_CWORD_CONF)) {
308			/* append a "Wrong C-bit" status code */
309			st.status_code = S_WRONG_CBIT;
310			st.msg_id = map->msg_id;
311			st.msg_type = htons(MSG_TYPE_LABELMAPPING);
312			lde_send_labelwithdraw(ln, fn, NULL, &st);
313
314			pw->flags &= ~F_PW_CWORD;
315			lde_send_labelmapping(ln, fn, 1);
316			}
317			} else if (map->flags & F_MAP_PW_CWORD) {
318			if (pw->flags & F_PW_CWORD_CONF)
319			pw->flags \|= F_PW_CWORD;
320			else
321			/* act as if no label mapping had been received */
322			return (1);
323			} else
324			pw->flags &= ~F_PW_CWORD;
325
326			/* RFC4447 - Section 5.4.3: pseudowire status negotiation */
327			if (fec_find(&ln->recv_map, &fn->fec) == NULL &&
328			!(map->flags & F_MAP_PW_STATUS))
329			pw->flags &= ~F_PW_STATUSTLV;
330
331			return (0);
332			}
333
334			void
335			l2vpn_send_pw_status(struct lde_nbr ln, uint32_t status, struct fec fec)
336			{
337			struct notify_msg nm;
338
339			memset(&nm, 0, sizeof(nm));
340			nm.status_code = S_PW_STATUS;
341			nm.pw_status = status;
342			nm.flags \|= F_NOTIF_PW_STATUS;
343			lde_fec2map(fec, &nm.fec);
344			nm.flags \|= F_NOTIF_FEC;
345
346			lde_imsg_compose_ldpe(IMSG_NOTIFICATION_SEND, ln->peerid, 0, &nm,
347			sizeof(nm));
348			}
349
350			void
351			l2vpn_send_pw_status_wcard(struct lde_nbr *ln, uint32_t status,
352			uint16_t pw_type, uint32_t group_id)
353			{
354			struct notify_msg nm;
355
356			memset(&nm, 0, sizeof(nm));
357			nm.status_code = S_PW_STATUS;
358			nm.pw_status = status;
359			nm.flags \|= F_NOTIF_PW_STATUS;
360			nm.fec.type = MAP_TYPE_PWID;
361			nm.fec.fec.pwid.type = pw_type;
362			nm.fec.fec.pwid.group_id = group_id;
363			nm.flags \|= F_NOTIF_FEC;
364
365			lde_imsg_compose_ldpe(IMSG_NOTIFICATION_SEND, ln->peerid, 0, &nm,
366			sizeof(nm));
367			}
368
369			void
370			l2vpn_recv_pw_status(struct lde_nbr ln, struct notify_msg nm)
371			{
372			struct fec fec;
373			struct fec_node *fn;
374			struct fec_nh *fnh;
375			struct l2vpn_pw *pw;
376
377			if (nm->fec.type == MAP_TYPE_TYPED_WCARD \|\|
378			!(nm->fec.flags & F_MAP_PW_ID)) {
379			l2vpn_recv_pw_status_wcard(ln, nm);
380			return;
381			}
382
383			lde_map2fec(&nm->fec, ln->id, &fec);
384			fn = (struct fec_node *)fec_find(&ft, &fec);
385			if (fn == NULL)
386			/* unknown fec */
387			return;
388
389			pw = (struct l2vpn_pw *) fn->data;
390			if (pw == NULL)
391			return;
392
393			fnh = fec_nh_find(fn, AF_INET, (union ldpd_addr *)&ln->id, 0);
394			if (fnh == NULL)
395			return;
396
397			/* remote status didn't change */
398			if (pw->remote_status == nm->pw_status)
399			return;
400			pw->remote_status = nm->pw_status;
401
402			if (l2vpn_pw_ok(pw, fnh))
403			lde_send_change_klabel(fn, fnh);
404			else
405			lde_send_delete_klabel(fn, fnh);
406			}
407
408			/* RFC4447 PWid group wildcard */
409			void
410			l2vpn_recv_pw_status_wcard(struct lde_nbr ln, struct notify_msg nm)
411			{
412			struct fec *f;
413			struct fec_node *fn;
414			struct fec_nh *fnh;
415			struct l2vpn_pw *pw;
416			struct map *wcard = &nm->fec;
417
418			RB_FOREACH(f, fec_tree, &ft) {
419			fn = (struct fec_node *)f;
420			if (fn->fec.type != FEC_TYPE_PWID)
421			continue;
422
423			pw = (struct l2vpn_pw *) fn->data;
424			if (pw == NULL)
425			continue;
426
427			switch (wcard->type) {
428			case MAP_TYPE_TYPED_WCARD:
429			if (wcard->fec.twcard.u.pw_type != PW_TYPE_WILDCARD &&
430			wcard->fec.twcard.u.pw_type != fn->fec.u.pwid.type)
431			continue;
432			break;
433			case MAP_TYPE_PWID:
434			if (wcard->fec.pwid.type != fn->fec.u.pwid.type)
435			continue;
436			if (wcard->fec.pwid.group_id != pw->remote_group)
437			continue;
438			break;
439			}
440
441			fnh = fec_nh_find(fn, AF_INET, (union ldpd_addr *)&ln->id, 0);
442			if (fnh == NULL)
443			continue;
444
445			/* remote status didn't change */
446			if (pw->remote_status == nm->pw_status)
447			continue;
448			pw->remote_status = nm->pw_status;
449
450			if (l2vpn_pw_ok(pw, fnh))
451			lde_send_change_klabel(fn, fnh);
452			else
453			lde_send_delete_klabel(fn, fnh);
454			}
455			}
456
457			void
458			l2vpn_sync_pws(int af, union ldpd_addr *addr)
459			{
460			struct l2vpn *l2vpn;
461			struct l2vpn_pw *pw;
462			struct fec fec;
463			struct fec_node *fn;
464			struct fec_nh *fnh;
465
466			LIST_FOREACH(l2vpn, &ldeconf->l2vpn_list, entry) {
467			LIST_FOREACH(pw, &l2vpn->pw_list, entry) {
468			if (af != pw->af \|\| ldp_addrcmp(af, &pw->addr, addr))
469			continue;
470
471			l2vpn_pw_fec(pw, &fec);
472			fn = (struct fec_node *)fec_find(&ft, &fec);
473			if (fn == NULL)
474			continue;
475			fnh = fec_nh_find(fn, AF_INET, (union ldpd_addr *)
476			&pw->lsr_id, 0);
477			if (fnh == NULL)
478			continue;
479
480			if (l2vpn_pw_ok(pw, fnh))
481			lde_send_change_klabel(fn, fnh);
482			else
483			lde_send_delete_klabel(fn, fnh);
484			}
485			}
486			}
487
488			void
489			l2vpn_pw_ctl(pid_t pid)
490			{
491			struct l2vpn *l2vpn;
492			struct l2vpn_pw *pw;
493			static struct ctl_pw pwctl;
494
495			LIST_FOREACH(l2vpn, &ldeconf->l2vpn_list, entry)
496			LIST_FOREACH(pw, &l2vpn->pw_list, entry) {
497			memset(&pwctl, 0, sizeof(pwctl));
498			strlcpy(pwctl.ifname, pw->ifname,
499			sizeof(pwctl.ifname));
500			pwctl.pwid = pw->pwid;
501			pwctl.lsr_id = pw->lsr_id;
502			pwctl.status = pw->flags & F_PW_STATUS_UP;
503
504			lde_imsg_compose_ldpe(IMSG_CTL_SHOW_L2VPN_PW, 0,
505			pid, &pwctl, sizeof(pwctl));
506			}
507			}
508
509			void
510			l2vpn_binding_ctl(pid_t pid)
511			{
512			struct fec *f;
513			struct fec_node *fn;
514			struct lde_map *me;
515			struct l2vpn_pw *pw;
516			static struct ctl_pw pwctl;
517
518			RB_FOREACH(f, fec_tree, &ft) {
519			if (f->type != FEC_TYPE_PWID)
520			continue;
521
522			fn = (struct fec_node *)f;
523			if (fn->local_label == NO_LABEL &&
524			LIST_EMPTY(&fn->downstream))
525			continue;
526
527			memset(&pwctl, 0, sizeof(pwctl));
528			pwctl.type = f->u.pwid.type;
529			pwctl.pwid = f->u.pwid.pwid;
530			pwctl.lsr_id = f->u.pwid.lsr_id;
531
532			pw = (struct l2vpn_pw *) fn->data;
533			if (pw) {
534			pwctl.local_label = fn->local_label;
535			pwctl.local_gid = 0;
536			pwctl.local_ifmtu = pw->l2vpn->mtu;
537			} else
538			pwctl.local_label = NO_LABEL;
539
540			LIST_FOREACH(me, &fn->downstream, entry)
541			if (f->u.pwid.lsr_id.s_addr == me->nexthop->id.s_addr)
542			break;
543
544			if (me) {
545			pwctl.remote_label = me->map.label;
546			pwctl.remote_gid = me->map.fec.pwid.group_id;
547			if (me->map.flags & F_MAP_PW_IFMTU)
548			pwctl.remote_ifmtu = me->map.fec.pwid.ifmtu;
549
550			lde_imsg_compose_ldpe(IMSG_CTL_SHOW_L2VPN_BINDING,
551			0, pid, &pwctl, sizeof(pwctl));
552			} else if (pw) {
553			pwctl.remote_label = NO_LABEL;
554
555			lde_imsg_compose_ldpe(IMSG_CTL_SHOW_L2VPN_BINDING,
556			0, pid, &pwctl, sizeof(pwctl));
557			}
558			}
559			}
560
561			/* ldpe */
562
563			void
564			ldpe_l2vpn_init(struct l2vpn *l2vpn)
565			{
566			struct l2vpn_pw *pw;
567
568			LIST_FOREACH(pw, &l2vpn->pw_list, entry)
569			ldpe_l2vpn_pw_init(pw);
570			}
571
572			void
573			ldpe_l2vpn_exit(struct l2vpn *l2vpn)
574			{
575			struct l2vpn_pw *pw;
576
577			LIST_FOREACH(pw, &l2vpn->pw_list, entry)
578			ldpe_l2vpn_pw_exit(pw);
579			}
580
581			void
582			ldpe_l2vpn_pw_init(struct l2vpn_pw *pw)
583			{
584			struct tnbr *tnbr;
585
586			tnbr = tnbr_find(leconf, pw->af, &pw->addr);
587			if (tnbr == NULL) {
588			tnbr = tnbr_new(leconf, pw->af, &pw->addr);
589			tnbr_update(tnbr);
590			LIST_INSERT_HEAD(&leconf->tnbr_list, tnbr, entry);
591			}
592
593			tnbr->pw_count++;
594			}
595
596			void
597			ldpe_l2vpn_pw_exit(struct l2vpn_pw *pw)
598			{
599			struct tnbr *tnbr;
600
601			tnbr = tnbr_find(leconf, pw->af, &pw->addr);
602			if (tnbr) {
603			tnbr->pw_count--;
604			tnbr_check(tnbr);
605			}
606			}