NetBSD/usr.sbin/ldpd/label.c

/* $NetBSD: label.c,v 1.11 2013/07/31 06:58:23 kefren Exp $ */

/*-
 * Copyright (c) 2010 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Mihai Chelaru <kefren@NetBSD.org>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <netmpls/mpls.h>

#include <assert.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>

#include "ldp.h"
#include "tlv_stack.h"
#include "mpls_routes.h"
#include "label.h"
#include "ldp_errors.h"

static int labels_compare(void*, const void*, const void*);

int min_label = MIN_LABEL, max_label = MAX_LABEL;

static rb_tree_t labels_tree;
static const rb_tree_ops_t tree_ops = {
	.rbto_compare_nodes = labels_compare,
	.rbto_compare_key = labels_compare,
	.rbto_node_offset = offsetof(struct label, lbtree),
	.rbto_context = NULL
};

void 
label_init()
{

	rb_tree_init(&labels_tree, &tree_ops);
}

static int
labels_compare(void *context, const void *node1, const void *node2)
{
	const struct label *l1 = node1, *l2 = node2;
	int ret;

	if (__predict_false(l1->so_dest.sa.sa_family !=
	    l2->so_dest.sa.sa_family))
		return l1->so_dest.sa.sa_family > l2->so_dest.sa.sa_family ?
		    1 : -1;

	assert(l1->so_dest.sa.sa_len == l2->so_dest.sa.sa_len);
	assert(l1->so_pref.sa.sa_len == l2->so_pref.sa.sa_len);

	if ((ret = memcmp(&l1->so_dest.sa, &l2->so_dest.sa,
	    l1->so_dest.sa.sa_len)) != 0)
		return ret;
	else
		return memcmp(&l1->so_pref.sa, &l2->so_pref.sa,
		    l1->so_pref.sa.sa_len);
}

/*
 * if binding == 0 it receives a free one
 */
struct label   *
label_add(const union sockunion * so_dest, const union sockunion * so_pref,
	  const union sockunion * so_gate, uint32_t binding,
	  const struct ldp_peer * p, uint32_t label, bool host)
{
	struct label   *l;
	char	spreftmp[INET_ADDRSTRLEN];

	l = calloc(1, sizeof(*l));

	if (!l) {
		fatalp("label_add: malloc problem\n");
		return NULL;
	}

	assert(so_dest);
	assert(so_pref);
	assert(so_dest->sa.sa_family == so_pref->sa.sa_family);
	assert(label_get(so_dest, so_pref) == NULL);

	memcpy(&l->so_dest, so_dest, so_dest->sa.sa_len);
	memcpy(&l->so_pref, so_pref, so_pref->sa.sa_len);

	if (so_gate)
		memcpy(&l->so_gate, so_gate, so_gate->sa.sa_len);
	if (binding)
		l->binding = binding;
	else
		l->binding = get_free_local_label();
	l->p = p;
	l->label = label;
	l->host = host;

	if (rb_tree_insert_node(&labels_tree, l) != l)
		fatalp("label already in tree");

	strlcpy(spreftmp, satos(&so_pref->sa), INET_ADDRSTRLEN);
	warnp("[label_add] added binding %d for %s/%s\n", l->binding,
	    satos(&so_dest->sa), spreftmp);

	send_label_tlv_to_all(&(so_dest->sa),
	    from_union_to_cidr(so_pref), l->binding);
	return l;
}

/* Unlink a label */
void 
label_del(struct label * l)
{
	warnp("[label_del] deleted binding %d for %s\n", l->binding,
	   satos(&l->so_dest.sa));
	rb_tree_remove_node(&labels_tree, l);
	free(l);
}

/*
 * Delete or Reuse the old IPv4 route, delete MPLS route
 * readd = REATT_INET_CHANGE -> delete and recreate the INET route
 * readd = REATT_INET_DEL -> deletes INET route
 * readd = REATT_INET_NODEL -> doesn't touch the INET route
 */
void
label_reattach_route(struct label *l, int readd)
{

	warnp("[label_reattach_route] binding %d deleted\n",
		l->binding);

	/* No gateway ? */
	if (l->so_gate.sa.sa_len == 0)
		return;

	if (readd == REATT_INET_CHANGE) {
		/* Delete the tagged route and re-add IPv4 route */
		delete_route(&l->so_dest,
		    l->host ? NULL : &l->so_pref, NO_FREESO);
		add_route(&l->so_dest,
		    l->host ? NULL : &l->so_pref, &l->so_gate,
		    NULL, NULL, NO_FREESO, RTM_READD);
	} else if (readd == REATT_INET_DEL)
		delete_route(&l->so_dest, l->host ? NULL : &l->so_pref,
		    NO_FREESO);

	/* Deletes the MPLS route */
	if (l->binding >= min_label)
		delete_route(make_mpls_union(l->binding), NULL, FREESO);

	l->binding = MPLS_LABEL_IMPLNULL;
	l->p = NULL;
	l->label = 0;
}
/*
 * Get a label by dst and pref
 */
struct label*
label_get(const union sockunion *sodest, const union sockunion *sopref)
{
	struct label l;

	memset(&l, 0, sizeof(l));
	memcpy(&l.so_dest, sodest, sodest->sa.sa_len);
	memcpy(&l.so_pref, sopref, sopref->sa.sa_len);

	return rb_tree_find_node(&labels_tree, &l);
}

/*
 * Find all labels that points to a peer
 * and reattach them to IPv4
 */
void
label_reattach_all_peer_labels(const struct ldp_peer *p, int readd)
{
	struct label   *l;

	RB_TREE_FOREACH(l, &labels_tree)
		if (l->p == p)
			label_reattach_route(l, readd);
}

/*
 * Find all labels that points to a peer
 * and delete them
 */
void 
del_all_peer_labels(const struct ldp_peer * p, int readd)
{
	struct label   *l, *lnext;

	RB_TREE_FOREACH(l, &labels_tree) {
back_delete:
		if(l->p != p)
			continue;
		label_reattach_route(l, readd);
		lnext = rb_tree_iterate(&labels_tree, l, RB_DIR_RIGHT);
		label_del(l);
		if (lnext == NULL)
			break;
		l = lnext;
		goto back_delete;
	}
}

/*
 * Finds a label by its binding and deletes it
 */
void 
label_del_by_binding(uint32_t binding, int readd)
{
	struct label   *l;

	RB_TREE_FOREACH(l, &labels_tree)
		if ((uint32_t)l->binding == binding) {
			label_reattach_route(l, readd);
			label_del(l);
			break;
		}
}

/*
 * For Compatibility with old bindinds code
 */
struct label*
label_get_by_prefix(const struct sockaddr *a, int prefixlen)
{
	const union sockunion *so_dest;
	union sockunion *so_pref;
	struct label *l;

	so_dest = (const union sockunion *)a;
	so_pref = from_cidr_to_union(prefixlen);

	l = label_get(so_dest, so_pref);

	free(so_pref);

	return l;
}

/*
 * Get a free binding
 */
uint32_t
get_free_local_label()
{
	struct label *l;
	int lbl;
 
	for (lbl = min_label; lbl <= max_label; lbl++) {
		RB_TREE_FOREACH(l, &labels_tree)
			if (l->binding == lbl)
				break;
		if (l == NULL)
			return lbl;
	}
	return 0;
}

/*
 * Announce peers that a label has changed its binding
 * by withdrawing it and reannouncing it
 */
void
announce_label_change(struct label *l)
{
	send_withdraw_tlv_to_all(&(l->so_dest.sa),
		from_union_to_cidr(&(l->so_pref)));
	send_label_tlv_to_all(&(l->so_dest.sa),
		from_union_to_cidr(&(l->so_pref)),
		l->binding);
}

void
label_check_assoc(struct ldp_peer *p)
{
	struct label *l;
	struct ldp_peer_address *wp;

	RB_TREE_FOREACH(l, &labels_tree)
		if (l->p == NULL && l->so_gate.sa.sa_family != 0)
			SLIST_FOREACH(wp, &p->ldp_peer_address_head, addresses)
				if (sockaddr_cmp(&l->so_gate.sa,
				    &wp->address.sa) == 0) {
					l->p = p;
					l->label = MPLS_LABEL_IMPLNULL;
					break;
				}
}

struct label *
label_get_right(struct label *l)
{
	if (l == NULL)
		return RB_TREE_MIN(&labels_tree);
	else
		return rb_tree_iterate(&labels_tree, l, RB_DIR_RIGHT);
}