[mirror_frr.git] / bgpd / bgp_nexthop.c

/* BGP nexthop scan
 * Copyright (C) 2000 Kunihiro Ishiguro
 *
 * This file is part of GNU Zebra.
 *
 * GNU Zebra is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * GNU Zebra is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; see the file COPYING; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <zebra.h>

#include "command.h"
#include "thread.h"
#include "prefix.h"
#include "zclient.h"
#include "stream.h"
#include "network.h"
#include "log.h"
#include "memory.h"
#include "hash.h"
#include "jhash.h"
#include "nexthop.h"
#include "queue.h"
#include "filter.h"

#include "bgpd/bgpd.h"
#include "bgpd/bgp_table.h"
#include "bgpd/bgp_route.h"
#include "bgpd/bgp_attr.h"
#include "bgpd/bgp_nexthop.h"
#include "bgpd/bgp_nht.h"
#include "bgpd/bgp_debug.h"
#include "bgpd/bgp_damp.h"
#include "bgpd/bgp_fsm.h"
#include "bgpd/bgp_vty.h"
#include "zebra/rib.h"
#include "zebra/zserv.h" /* For ZEBRA_SERV_PATH. */

char *bnc_str(struct bgp_nexthop_cache *bnc, char *buf, int size)
{
	prefix2str(&(bnc->node->p), buf, size);
	return buf;
}

void bnc_nexthop_free(struct bgp_nexthop_cache *bnc)
{
	nexthops_free(bnc->nexthop);
}

struct bgp_nexthop_cache *bnc_new(void)
{
	struct bgp_nexthop_cache *bnc;

	bnc = XCALLOC(MTYPE_BGP_NEXTHOP_CACHE,
		      sizeof(struct bgp_nexthop_cache));
	LIST_INIT(&(bnc->paths));
	return bnc;
}

void bnc_free(struct bgp_nexthop_cache *bnc)
{
	bnc_nexthop_free(bnc);
	XFREE(MTYPE_BGP_NEXTHOP_CACHE, bnc);
}

/* Reset and free all BGP nexthop cache. */
static void bgp_nexthop_cache_reset(struct bgp_table *table)
{
	struct bgp_node *rn;
	struct bgp_nexthop_cache *bnc;

	for (rn = bgp_table_top(table); rn; rn = bgp_route_next(rn))
		if ((bnc = rn->info) != NULL) {
			bnc_free(bnc);
			rn->info = NULL;
			bgp_unlock_node(rn);
		}
}

static void *bgp_tip_hash_alloc(void *p)
{
	const struct in_addr *val = (const struct in_addr *)p;
	struct tip_addr *addr;

	addr = XMALLOC(MTYPE_TIP_ADDR, sizeof(struct tip_addr));
	addr->refcnt = 0;
	addr->addr.s_addr = val->s_addr;

	return addr;
}

static void bgp_tip_hash_free(void *addr)
{
	XFREE(MTYPE_TIP_ADDR, addr);
}

static unsigned int bgp_tip_hash_key_make(void *p)
{
	const struct tip_addr *addr = p;

	return jhash_1word(addr->addr.s_addr, 0);
}

static int bgp_tip_hash_cmp(const void *p1, const void *p2)
{
	const struct tip_addr *addr1 = p1;
	const struct tip_addr *addr2 = p2;

	return addr1->addr.s_addr == addr2->addr.s_addr;
}

void bgp_tip_hash_init(struct bgp *bgp)
{
	bgp->tip_hash = hash_create(bgp_tip_hash_key_make, bgp_tip_hash_cmp,
				    "BGP TIP hash");
}

void bgp_tip_hash_destroy(struct bgp *bgp)
{
	if (bgp->tip_hash == NULL)
		return;
	hash_clean(bgp->tip_hash, bgp_tip_hash_free);
	hash_free(bgp->tip_hash);
	bgp->tip_hash = NULL;
}

void bgp_tip_add(struct bgp *bgp, struct in_addr *tip)
{
	struct tip_addr tmp;
	struct tip_addr *addr;

	tmp.addr = *tip;

	addr = hash_get(bgp->tip_hash, &tmp, bgp_tip_hash_alloc);
	if (!addr)
		return;

	addr->refcnt++;
}

void bgp_tip_del(struct bgp *bgp, struct in_addr *tip)
{
	struct tip_addr tmp;
	struct tip_addr *addr;

	tmp.addr = *tip;

	addr = hash_lookup(bgp->tip_hash, &tmp);
	/* may have been deleted earlier by bgp_interface_down() */
	if (addr == NULL)
		return;

	addr->refcnt--;

	if (addr->refcnt == 0) {
		hash_release(bgp->tip_hash, addr);
		XFREE(MTYPE_TIP_ADDR, addr);
	}
}

static void *bgp_address_hash_alloc(void *p)
{
	const struct in_addr *val = (const struct in_addr *)p;
	struct bgp_addr *addr;

	addr = XMALLOC(MTYPE_BGP_ADDR, sizeof(struct bgp_addr));
	addr->refcnt = 0;
	addr->addr.s_addr = val->s_addr;

	return addr;
}

static void bgp_address_hash_free(void *addr)
{
	XFREE(MTYPE_BGP_ADDR, addr);
}

static unsigned int bgp_address_hash_key_make(void *p)
{
	const struct bgp_addr *addr = p;

	return jhash_1word(addr->addr.s_addr, 0);
}

static int bgp_address_hash_cmp(const void *p1, const void *p2)
{
	const struct bgp_addr *addr1 = p1;
	const struct bgp_addr *addr2 = p2;

	return addr1->addr.s_addr == addr2->addr.s_addr;
}

void bgp_address_init(struct bgp *bgp)
{
	bgp->address_hash =
		hash_create(bgp_address_hash_key_make, bgp_address_hash_cmp,
			    "BGP Address Hash");
}

void bgp_address_destroy(struct bgp *bgp)
{
	if (bgp->address_hash == NULL)
		return;
	hash_clean(bgp->address_hash, bgp_address_hash_free);
	hash_free(bgp->address_hash);
	bgp->address_hash = NULL;
}

static void bgp_address_add(struct bgp *bgp, struct prefix *p)
{
	struct bgp_addr tmp;
	struct bgp_addr *addr;

	tmp.addr = p->u.prefix4;

	addr = hash_get(bgp->address_hash, &tmp, bgp_address_hash_alloc);
	if (!addr)
		return;

	addr->refcnt++;
}

static void bgp_address_del(struct bgp *bgp, struct prefix *p)
{
	struct bgp_addr tmp;
	struct bgp_addr *addr;

	tmp.addr = p->u.prefix4;

	addr = hash_lookup(bgp->address_hash, &tmp);
	/* may have been deleted earlier by bgp_interface_down() */
	if (addr == NULL)
		return;

	addr->refcnt--;

	if (addr->refcnt == 0) {
		hash_release(bgp->address_hash, addr);
		XFREE(MTYPE_BGP_ADDR, addr);
	}
}


struct bgp_connected_ref {
	unsigned int refcnt;
};

void bgp_connected_add(struct bgp *bgp, struct connected *ifc)
{
	struct prefix p;
	struct prefix *addr;
	struct bgp_node *rn;
	struct bgp_connected_ref *bc;
	struct listnode *node, *nnode;
	struct peer *peer;

	addr = ifc->address;

	p = *(CONNECTED_PREFIX(ifc));
	if (addr->family == AF_INET) {
		apply_mask_ipv4((struct prefix_ipv4 *)&p);

		if (prefix_ipv4_any((struct prefix_ipv4 *)&p))
			return;

		bgp_address_add(bgp, addr);

		rn = bgp_node_get(bgp->connected_table[AFI_IP],
				  (struct prefix *)&p);
		if (rn->info) {
			bc = rn->info;
			bc->refcnt++;
		} else {
			bc = XCALLOC(MTYPE_BGP_CONN,
				     sizeof(struct bgp_connected_ref));
			bc->refcnt = 1;
			rn->info = bc;
		}

		for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
			if (peer->conf_if
			    && (strcmp(peer->conf_if, ifc->ifp->name) == 0)
			    && peer->status != Established
			    && !CHECK_FLAG(peer->flags,
					   PEER_FLAG_IFPEER_V6ONLY)) {
				if (peer_active(peer))
					BGP_EVENT_ADD(peer, BGP_Stop);
				BGP_EVENT_ADD(peer, BGP_Start);
			}
		}
	} else if (addr->family == AF_INET6) {
		apply_mask_ipv6((struct prefix_ipv6 *)&p);

		if (IN6_IS_ADDR_UNSPECIFIED(&p.u.prefix6))
			return;

		if (IN6_IS_ADDR_LINKLOCAL(&p.u.prefix6))
			return;

		rn = bgp_node_get(bgp->connected_table[AFI_IP6],
				  (struct prefix *)&p);
		if (rn->info) {
			bc = rn->info;
			bc->refcnt++;
		} else {
			bc = XCALLOC(MTYPE_BGP_CONN,
				     sizeof(struct bgp_connected_ref));
			bc->refcnt = 1;
			rn->info = bc;
		}
	}
}

void bgp_connected_delete(struct bgp *bgp, struct connected *ifc)
{
	struct prefix p;
	struct prefix *addr;
	struct bgp_node *rn;
	struct bgp_connected_ref *bc;

	addr = ifc->address;

	p = *(CONNECTED_PREFIX(ifc));
	if (addr->family == AF_INET) {
		apply_mask_ipv4((struct prefix_ipv4 *)&p);

		if (prefix_ipv4_any((struct prefix_ipv4 *)&p))
			return;

		bgp_address_del(bgp, addr);

		rn = bgp_node_lookup(bgp->connected_table[AFI_IP], &p);
		if (!rn)
			return;

		bc = rn->info;
		bc->refcnt--;
		if (bc->refcnt == 0) {
			XFREE(MTYPE_BGP_CONN, bc);
			rn->info = NULL;
		}
		bgp_unlock_node(rn);
		bgp_unlock_node(rn);
	} else if (addr->family == AF_INET6) {
		apply_mask_ipv6((struct prefix_ipv6 *)&p);

		if (IN6_IS_ADDR_UNSPECIFIED(&p.u.prefix6))
			return;

		if (IN6_IS_ADDR_LINKLOCAL(&p.u.prefix6))
			return;

		rn = bgp_node_lookup(bgp->connected_table[AFI_IP6],
				     (struct prefix *)&p);
		if (!rn)
			return;

		bc = rn->info;
		bc->refcnt--;
		if (bc->refcnt == 0) {
			XFREE(MTYPE_BGP_CONN, bc);
			rn->info = NULL;
		}
		bgp_unlock_node(rn);
		bgp_unlock_node(rn);
	}
}

int bgp_nexthop_self(struct bgp *bgp, struct in_addr nh_addr)
{
	struct bgp_addr tmp, *addr;
	struct tip_addr tmp_tip, *tip;

	tmp.addr = nh_addr;

	addr = hash_lookup(bgp->address_hash, &tmp);
	if (addr)
		return 1;

	tmp_tip.addr = nh_addr;
	tip = hash_lookup(bgp->tip_hash, &tmp_tip);
	if (tip)
		return 1;

	return 0;
}

int bgp_multiaccess_check_v4(struct in_addr nexthop, struct peer *peer)
{
	struct bgp_node *rn1;
	struct bgp_node *rn2;
	struct prefix p;
	int ret;

	p.family = AF_INET;
	p.prefixlen = IPV4_MAX_BITLEN;
	p.u.prefix4 = nexthop;

	rn1 = bgp_node_match(peer->bgp->connected_table[AFI_IP], &p);
	if (!rn1)
		return 0;

	p.family = AF_INET;
	p.prefixlen = IPV4_MAX_BITLEN;
	p.u.prefix4 = peer->su.sin.sin_addr;

	rn2 = bgp_node_match(peer->bgp->connected_table[AFI_IP], &p);
	if (!rn2) {
		bgp_unlock_node(rn1);
		return 0;
	}

	ret = (rn1 == rn2) ? 1 : 0;

	bgp_unlock_node(rn1);
	bgp_unlock_node(rn2);

	return (ret);
}

int bgp_subgrp_multiaccess_check_v4(struct in_addr nexthop,
				    struct update_subgroup *subgrp)
{
	struct bgp_node *rn1, *rn2;
	struct peer_af *paf;
	struct prefix p, np;
	struct bgp *bgp = NULL;

	np.family = AF_INET;
	np.prefixlen = IPV4_MAX_BITLEN;
	np.u.prefix4 = nexthop;

	p.family = AF_INET;
	p.prefixlen = IPV4_MAX_BITLEN;

	rn1 = rn2 = NULL;

	bgp = SUBGRP_INST(subgrp);
	rn1 = bgp_node_match(bgp->connected_table[AFI_IP], &np);
	if (!rn1)
		return 0;

	SUBGRP_FOREACH_PEER (subgrp, paf) {
		p.u.prefix4 = paf->peer->su.sin.sin_addr;

		rn2 = bgp_node_match(bgp->connected_table[AFI_IP], &p);
		if (rn1 == rn2) {
			bgp_unlock_node(rn1);
			bgp_unlock_node(rn2);
			return 1;
		}

		if (rn2)
			bgp_unlock_node(rn2);
	}

	bgp_unlock_node(rn1);
	return 0;
}

static void bgp_show_nexthops_detail(struct vty *vty, struct bgp *bgp,
				     struct bgp_nexthop_cache *bnc)
{
	char buf[PREFIX2STR_BUFFER];
	struct nexthop *nexthop;

	for (nexthop = bnc->nexthop; nexthop; nexthop = nexthop->next)
		switch (nexthop->type) {
		case NEXTHOP_TYPE_IPV6:
			vty_out(vty, "  gate %s\n",
				inet_ntop(AF_INET6, &nexthop->gate.ipv6, buf,
					  sizeof(buf)));
			break;
		case NEXTHOP_TYPE_IPV6_IFINDEX:
			vty_out(vty, "  gate %s, if %s\n",
				inet_ntop(AF_INET6, &nexthop->gate.ipv6, buf,
					  sizeof(buf)),
				ifindex2ifname(nexthop->ifindex, bgp->vrf_id));
			break;
		case NEXTHOP_TYPE_IPV4:
			vty_out(vty, "  gate %s\n",
				inet_ntop(AF_INET, &nexthop->gate.ipv4, buf,
					  sizeof(buf)));
			break;
		case NEXTHOP_TYPE_IFINDEX:
			vty_out(vty, "  if %s\n",
				ifindex2ifname(nexthop->ifindex, bgp->vrf_id));
			break;
		case NEXTHOP_TYPE_IPV4_IFINDEX:
			vty_out(vty, "  gate %s, if %s\n",
				inet_ntop(AF_INET, &nexthop->gate.ipv4, buf,
					  sizeof(buf)),
				ifindex2ifname(nexthop->ifindex, bgp->vrf_id));
			break;
		case NEXTHOP_TYPE_BLACKHOLE:
			vty_out(vty, "  blackhole\n");
			break;
		default:
			vty_out(vty, "  invalid nexthop type %u\n",
				nexthop->type);
		}
}

static void bgp_show_nexthops(struct vty *vty, struct bgp *bgp, int detail)
{
	struct bgp_node *rn;
	struct bgp_nexthop_cache *bnc;
	char buf[PREFIX2STR_BUFFER];
	time_t tbuf;
	afi_t afi;

	vty_out(vty, "Current BGP nexthop cache:\n");
	for (afi = AFI_IP; afi < AFI_MAX; afi++) {
		if (!bgp->nexthop_cache_table[afi])
			continue;

		for (rn = bgp_table_top(bgp->nexthop_cache_table[afi]); rn;
		     rn = bgp_route_next(rn)) {
			if ((bnc = rn->info) != NULL) {
				if (CHECK_FLAG(bnc->flags, BGP_NEXTHOP_VALID)) {
					vty_out(vty,
						" %s valid [IGP metric %d], #paths %d\n",
						inet_ntop(rn->p.family,
							  &rn->p.u.prefix, buf,
							  sizeof(buf)),
						bnc->metric, bnc->path_count);

					if (!detail)
						continue;

					bgp_show_nexthops_detail(vty, bgp, bnc);

				} else {
					vty_out(vty, " %s invalid\n",
						inet_ntop(rn->p.family,
							  &rn->p.u.prefix, buf,
							  sizeof(buf)));
					if (CHECK_FLAG(bnc->flags,
						       BGP_NEXTHOP_CONNECTED))
						vty_out(vty,
							"  Must be Connected\n");
				}
				tbuf = time(NULL)
				       - (bgp_clock() - bnc->last_update);
				vty_out(vty, "  Last update: %s", ctime(&tbuf));
				vty_out(vty, "\n");
			}
		}
	}
}

static int show_ip_bgp_nexthop_table(struct vty *vty, const char *name,
				     int detail)
{
	struct bgp *bgp;

	if (name)
		bgp = bgp_lookup_by_name(name);
	else
		bgp = bgp_get_default();
	if (!bgp) {
		vty_out(vty, "%% No such BGP instance exist\n");
		return CMD_WARNING;
	}

	bgp_show_nexthops(vty, bgp, detail);

	return CMD_SUCCESS;
}

static void bgp_show_all_instances_nexthops_vty(struct vty *vty)
{
	struct listnode *node, *nnode;
	struct bgp *bgp;

	for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
		vty_out(vty, "\nInstance %s:\n",
			(bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
				? "Default"
				: bgp->name);
		bgp_show_nexthops(vty, bgp, 0);
	}
}

DEFUN (show_ip_bgp_nexthop,
       show_ip_bgp_nexthop_cmd,
       "show [ip] bgp [<view|vrf> VIEWVRFNAME] nexthop [detail]",
       SHOW_STR
       IP_STR
       BGP_STR
       BGP_INSTANCE_HELP_STR
       "BGP nexthop table\n"
       "Show detailed information\n")
{
	int idx = 0;
	char *vrf = NULL;

	if (argv_find(argv, argc, "view", &idx)
	    || argv_find(argv, argc, "vrf", &idx))
		vrf = argv[++idx]->arg;
	int detail = argv_find(argv, argc, "detail", &idx) ? 1 : 0;
	return show_ip_bgp_nexthop_table(vty, vrf, detail);
}

DEFUN (show_ip_bgp_instance_all_nexthop,
       show_ip_bgp_instance_all_nexthop_cmd,
       "show [ip] bgp <view|vrf> all nexthop",
       SHOW_STR
       IP_STR
       BGP_STR
       BGP_INSTANCE_ALL_HELP_STR
       "BGP nexthop table\n")
{
	bgp_show_all_instances_nexthops_vty(vty);
	return CMD_SUCCESS;
}

void bgp_scan_init(struct bgp *bgp)
{
	afi_t afi;

	for (afi = AFI_IP; afi < AFI_MAX; afi++) {
		bgp->nexthop_cache_table[afi] =
			bgp_table_init(bgp, afi, SAFI_UNICAST);
		bgp->connected_table[afi] = bgp_table_init(bgp, afi,
			SAFI_UNICAST);
		bgp->import_check_table[afi] =
			bgp_table_init(bgp, afi, SAFI_UNICAST);
	}
}

void bgp_scan_vty_init(void)
{
	install_element(VIEW_NODE, &show_ip_bgp_nexthop_cmd);
	install_element(VIEW_NODE, &show_ip_bgp_instance_all_nexthop_cmd);
}

void bgp_scan_finish(struct bgp *bgp)
{
	afi_t afi;

	for (afi = AFI_IP; afi < AFI_MAX; afi++) {
		/* Only the current one needs to be reset. */
		bgp_nexthop_cache_reset(bgp->nexthop_cache_table[afi]);
		bgp_table_unlock(bgp->nexthop_cache_table[afi]);
		bgp->nexthop_cache_table[afi] = NULL;

		bgp_table_unlock(bgp->connected_table[afi]);
		bgp->connected_table[afi] = NULL;

		bgp_table_unlock(bgp->import_check_table[afi]);
		bgp->import_check_table[afi] = NULL;
	}
}
Commit	Line	Data
718e3744	1	/* BGP nexthop scan
896014f4 DL	2	* Copyright (C) 2000 Kunihiro Ishiguro
	3	*
	4	* This file is part of GNU Zebra.
	5	*
	6	* GNU Zebra is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License as published by the
	8	* Free Software Foundation; either version 2, or (at your option) any
	9	* later version.
	10	*
	11	* GNU Zebra is distributed in the hope that it will be useful, but
	12	* WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License along
	17	* with this program; see the file COPYING; if not, write to the Free Software
	18	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	19	*/
718e3744	20
	21	#include <zebra.h>
	22
	23	#include "command.h"
	24	#include "thread.h"
	25	#include "prefix.h"
	26	#include "zclient.h"
	27	#include "stream.h"
	28	#include "network.h"
	29	#include "log.h"
	30	#include "memory.h"
10f9bf3f JBD	31	#include "hash.h"
10f9bf3f JBD	32	#include "jhash.h"
fb018d25	33	#include "nexthop.h"
3f9c7369	34	#include "queue.h"
039f3a34	35	#include "filter.h"
718e3744	36
	37	#include "bgpd/bgpd.h"
	38	#include "bgpd/bgp_table.h"
	39	#include "bgpd/bgp_route.h"
	40	#include "bgpd/bgp_attr.h"
	41	#include "bgpd/bgp_nexthop.h"
fb018d25	42	#include "bgpd/bgp_nht.h"
718e3744	43	#include "bgpd/bgp_debug.h"
718e3744	44	#include "bgpd/bgp_damp.h"
8ffedcea	45	#include "bgpd/bgp_fsm.h"
8386ac43	46	#include "bgpd/bgp_vty.h"
718e3744	47	#include "zebra/rib.h"
d62a17ae	48	#include "zebra/zserv.h" /* For ZEBRA_SERV_PATH. */
718e3744	49
d62a17ae	50	char bnc_str(struct bgp_nexthop_cache bnc, char *buf, int size)
fb018d25	51	{
d62a17ae	52	prefix2str(&(bnc->node->p), buf, size);
d62a17ae	53	return buf;
fb018d25 DS	54	}
fb018d25 DS	55
d62a17ae	56	void bnc_nexthop_free(struct bgp_nexthop_cache *bnc)
718e3744	57	{
d62a17ae	58	nexthops_free(bnc->nexthop);
718e3744	59	}
718e3744	60
d62a17ae	61	struct bgp_nexthop_cache *bnc_new(void)
718e3744	62	{
d62a17ae	63	struct bgp_nexthop_cache *bnc;
fb018d25	64
d62a17ae	65	bnc = XCALLOC(MTYPE_BGP_NEXTHOP_CACHE,
	66	sizeof(struct bgp_nexthop_cache));
	67	LIST_INIT(&(bnc->paths));
	68	return bnc;
718e3744	69	}
718e3744	70
d62a17ae	71	void bnc_free(struct bgp_nexthop_cache *bnc)
718e3744	72	{
d62a17ae	73	bnc_nexthop_free(bnc);
d62a17ae	74	XFREE(MTYPE_BGP_NEXTHOP_CACHE, bnc);
718e3744	75	}
6b0655a2	76
718e3744	77	/* Reset and free all BGP nexthop cache. */
d62a17ae	78	static void bgp_nexthop_cache_reset(struct bgp_table *table)
718e3744	79	{
d62a17ae	80	struct bgp_node *rn;
	81	struct bgp_nexthop_cache *bnc;
	82
	83	for (rn = bgp_table_top(table); rn; rn = bgp_route_next(rn))
	84	if ((bnc = rn->info) != NULL) {
	85	bnc_free(bnc);
	86	rn->info = NULL;
	87	bgp_unlock_node(rn);
	88	}
718e3744	89	}
718e3744	90
db0e1937 MK	91	static void bgp_tip_hash_alloc(void p)
db0e1937 MK	92	{
0291c246 MK	93	const struct in_addr val = (const struct in_addr )p;
0291c246 MK	94	struct tip_addr *addr;
db0e1937 MK	95
	96	addr = XMALLOC(MTYPE_TIP_ADDR, sizeof(struct tip_addr));
	97	addr->refcnt = 0;
	98	addr->addr.s_addr = val->s_addr;
	99
	100	return addr;
	101	}
	102
	103	static void bgp_tip_hash_free(void *addr)
	104	{
	105	XFREE(MTYPE_TIP_ADDR, addr);
	106	}
	107
	108	static unsigned int bgp_tip_hash_key_make(void *p)
	109	{
0291c246	110	const struct tip_addr *addr = p;
db0e1937 MK	111
	112	return jhash_1word(addr->addr.s_addr, 0);
	113	}
	114
	115	static int bgp_tip_hash_cmp(const void p1, const void p2)
	116	{
0291c246 MK	117	const struct tip_addr *addr1 = p1;
0291c246 MK	118	const struct tip_addr *addr2 = p2;
db0e1937 MK	119
	120	return addr1->addr.s_addr == addr2->addr.s_addr;
	121	}
	122
	123	void bgp_tip_hash_init(struct bgp *bgp)
	124	{
996c9314	125	bgp->tip_hash = hash_create(bgp_tip_hash_key_make, bgp_tip_hash_cmp,
3f65c5b1	126	"BGP TIP hash");
db0e1937 MK	127	}
	128
	129	void bgp_tip_hash_destroy(struct bgp *bgp)
	130	{
	131	if (bgp->tip_hash == NULL)
	132	return;
	133	hash_clean(bgp->tip_hash, bgp_tip_hash_free);
	134	hash_free(bgp->tip_hash);
	135	bgp->tip_hash = NULL;
	136	}
	137
	138	void bgp_tip_add(struct bgp bgp, struct in_addr tip)
	139	{
0291c246 MK	140	struct tip_addr tmp;
0291c246 MK	141	struct tip_addr *addr;
db0e1937 MK	142
	143	tmp.addr = *tip;
	144
	145	addr = hash_get(bgp->tip_hash, &tmp, bgp_tip_hash_alloc);
	146	if (!addr)
	147	return;
	148
	149	addr->refcnt++;
	150	}
	151
	152	void bgp_tip_del(struct bgp bgp, struct in_addr tip)
	153	{
0291c246 MK	154	struct tip_addr tmp;
0291c246 MK	155	struct tip_addr *addr;
db0e1937 MK	156
	157	tmp.addr = *tip;
	158
	159	addr = hash_lookup(bgp->tip_hash, &tmp);
	160	/* may have been deleted earlier by bgp_interface_down() */
	161	if (addr == NULL)
	162	return;
	163
	164	addr->refcnt--;
	165
	166	if (addr->refcnt == 0) {
	167	hash_release(bgp->tip_hash, addr);
	168	XFREE(MTYPE_TIP_ADDR, addr);
	169	}
	170	}
10f9bf3f	171
d62a17ae	172	static void bgp_address_hash_alloc(void p)
10f9bf3f	173	{
d62a17ae	174	const struct in_addr val = (const struct in_addr )p;
d62a17ae	175	struct bgp_addr *addr;
10f9bf3f	176
d62a17ae	177	addr = XMALLOC(MTYPE_BGP_ADDR, sizeof(struct bgp_addr));
	178	addr->refcnt = 0;
	179	addr->addr.s_addr = val->s_addr;
10f9bf3f	180
d62a17ae	181	return addr;
10f9bf3f JBD	182	}
10f9bf3f JBD	183
d62a17ae	184	static void bgp_address_hash_free(void *addr)
37d361e7	185	{
d62a17ae	186	XFREE(MTYPE_BGP_ADDR, addr);
37d361e7 RW	187	}
37d361e7 RW	188
d62a17ae	189	static unsigned int bgp_address_hash_key_make(void *p)
10f9bf3f	190	{
d62a17ae	191	const struct bgp_addr *addr = p;
10f9bf3f	192
d62a17ae	193	return jhash_1word(addr->addr.s_addr, 0);
10f9bf3f JBD	194	}
10f9bf3f JBD	195
d62a17ae	196	static int bgp_address_hash_cmp(const void p1, const void p2)
10f9bf3f	197	{
d62a17ae	198	const struct bgp_addr *addr1 = p1;
d62a17ae	199	const struct bgp_addr *addr2 = p2;
10f9bf3f	200
d62a17ae	201	return addr1->addr.s_addr == addr2->addr.s_addr;
10f9bf3f JBD	202	}
10f9bf3f JBD	203
d62a17ae	204	void bgp_address_init(struct bgp *bgp)
10f9bf3f	205	{
996c9314 LB	206	bgp->address_hash =
	207	hash_create(bgp_address_hash_key_make, bgp_address_hash_cmp,
	208	"BGP Address Hash");
10f9bf3f JBD	209	}
10f9bf3f JBD	210
d62a17ae	211	void bgp_address_destroy(struct bgp *bgp)
bb86c601	212	{
d62a17ae	213	if (bgp->address_hash == NULL)
	214	return;
	215	hash_clean(bgp->address_hash, bgp_address_hash_free);
	216	hash_free(bgp->address_hash);
	217	bgp->address_hash = NULL;
bb86c601 LB	218	}
bb86c601 LB	219
d62a17ae	220	static void bgp_address_add(struct bgp bgp, struct prefix p)
10f9bf3f	221	{
d62a17ae	222	struct bgp_addr tmp;
d62a17ae	223	struct bgp_addr *addr;
10f9bf3f	224
d62a17ae	225	tmp.addr = p->u.prefix4;
10f9bf3f	226
d62a17ae	227	addr = hash_get(bgp->address_hash, &tmp, bgp_address_hash_alloc);
	228	if (!addr)
	229	return;
5ce10e92	230
d62a17ae	231	addr->refcnt++;
10f9bf3f JBD	232	}
10f9bf3f JBD	233
d62a17ae	234	static void bgp_address_del(struct bgp bgp, struct prefix p)
10f9bf3f	235	{
d62a17ae	236	struct bgp_addr tmp;
d62a17ae	237	struct bgp_addr *addr;
10f9bf3f	238
d62a17ae	239	tmp.addr = p->u.prefix4;
10f9bf3f	240
d62a17ae	241	addr = hash_lookup(bgp->address_hash, &tmp);
	242	/* may have been deleted earlier by bgp_interface_down() */
	243	if (addr == NULL)
	244	return;
9e47abd8	245
d62a17ae	246	addr->refcnt--;
10f9bf3f	247
d62a17ae	248	if (addr->refcnt == 0) {
	249	hash_release(bgp->address_hash, addr);
	250	XFREE(MTYPE_BGP_ADDR, addr);
	251	}
10f9bf3f JBD	252	}
10f9bf3f JBD	253
6b0655a2	254
d62a17ae	255	struct bgp_connected_ref {
d62a17ae	256	unsigned int refcnt;
718e3744	257	};
718e3744	258
d62a17ae	259	void bgp_connected_add(struct bgp bgp, struct connected ifc)
718e3744	260	{
d62a17ae	261	struct prefix p;
	262	struct prefix *addr;
	263	struct bgp_node *rn;
	264	struct bgp_connected_ref *bc;
	265	struct listnode node, nnode;
	266	struct peer *peer;
	267
	268	addr = ifc->address;
	269
	270	p = *(CONNECTED_PREFIX(ifc));
	271	if (addr->family == AF_INET) {
	272	apply_mask_ipv4((struct prefix_ipv4 *)&p);
	273
	274	if (prefix_ipv4_any((struct prefix_ipv4 *)&p))
	275	return;
	276
	277	bgp_address_add(bgp, addr);
	278
	279	rn = bgp_node_get(bgp->connected_table[AFI_IP],
	280	(struct prefix *)&p);
	281	if (rn->info) {
	282	bc = rn->info;
	283	bc->refcnt++;
	284	} else {
	285	bc = XCALLOC(MTYPE_BGP_CONN,
	286	sizeof(struct bgp_connected_ref));
	287	bc->refcnt = 1;
	288	rn->info = bc;
	289	}
8ffedcea	290
d62a17ae	291	for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer)) {
	292	if (peer->conf_if
	293	&& (strcmp(peer->conf_if, ifc->ifp->name) == 0)
	294	&& peer->status != Established
	295	&& !CHECK_FLAG(peer->flags,
	296	PEER_FLAG_IFPEER_V6ONLY)) {
	297	if (peer_active(peer))
	298	BGP_EVENT_ADD(peer, BGP_Stop);
	299	BGP_EVENT_ADD(peer, BGP_Start);
	300	}
	301	}
	302	} else if (addr->family == AF_INET6) {
	303	apply_mask_ipv6((struct prefix_ipv6 *)&p);
	304
	305	if (IN6_IS_ADDR_UNSPECIFIED(&p.u.prefix6))
	306	return;
	307
	308	if (IN6_IS_ADDR_LINKLOCAL(&p.u.prefix6))
	309	return;
	310
	311	rn = bgp_node_get(bgp->connected_table[AFI_IP6],
	312	(struct prefix *)&p);
	313	if (rn->info) {
	314	bc = rn->info;
	315	bc->refcnt++;
	316	} else {
	317	bc = XCALLOC(MTYPE_BGP_CONN,
	318	sizeof(struct bgp_connected_ref));
	319	bc->refcnt = 1;
	320	rn->info = bc;
	321	}
718e3744	322	}
718e3744	323	}
718e3744	324
d62a17ae	325	void bgp_connected_delete(struct bgp bgp, struct connected ifc)
718e3744	326	{
d62a17ae	327	struct prefix p;
	328	struct prefix *addr;
	329	struct bgp_node *rn;
	330	struct bgp_connected_ref *bc;
718e3744	331
d62a17ae	332	addr = ifc->address;
718e3744	333
d62a17ae	334	p = *(CONNECTED_PREFIX(ifc));
	335	if (addr->family == AF_INET) {
	336	apply_mask_ipv4((struct prefix_ipv4 *)&p);
718e3744	337
d62a17ae	338	if (prefix_ipv4_any((struct prefix_ipv4 *)&p))
d62a17ae	339	return;
718e3744	340
d62a17ae	341	bgp_address_del(bgp, addr);
10f9bf3f	342
d62a17ae	343	rn = bgp_node_lookup(bgp->connected_table[AFI_IP], &p);
	344	if (!rn)
	345	return;
718e3744	346
d62a17ae	347	bc = rn->info;
	348	bc->refcnt--;
	349	if (bc->refcnt == 0) {
	350	XFREE(MTYPE_BGP_CONN, bc);
	351	rn->info = NULL;
	352	}
	353	bgp_unlock_node(rn);
	354	bgp_unlock_node(rn);
	355	} else if (addr->family == AF_INET6) {
	356	apply_mask_ipv6((struct prefix_ipv6 *)&p);
	357
	358	if (IN6_IS_ADDR_UNSPECIFIED(&p.u.prefix6))
	359	return;
	360
	361	if (IN6_IS_ADDR_LINKLOCAL(&p.u.prefix6))
	362	return;
	363
	364	rn = bgp_node_lookup(bgp->connected_table[AFI_IP6],
	365	(struct prefix *)&p);
	366	if (!rn)
	367	return;
	368
	369	bc = rn->info;
	370	bc->refcnt--;
	371	if (bc->refcnt == 0) {
	372	XFREE(MTYPE_BGP_CONN, bc);
	373	rn->info = NULL;
	374	}
	375	bgp_unlock_node(rn);
	376	bgp_unlock_node(rn);
718e3744	377	}
718e3744	378	}
718e3744	379
d62a17ae	380	int bgp_nexthop_self(struct bgp *bgp, struct in_addr nh_addr)
718e3744	381	{
d62a17ae	382	struct bgp_addr tmp, *addr;
db0e1937	383	struct tip_addr tmp_tip, *tip;
718e3744	384
d62a17ae	385	tmp.addr = nh_addr;
10f9bf3f	386
d62a17ae	387	addr = hash_lookup(bgp->address_hash, &tmp);
	388	if (addr)
	389	return 1;
718e3744	390
db0e1937 MK	391	tmp_tip.addr = nh_addr;
	392	tip = hash_lookup(bgp->tip_hash, &tmp_tip);
	393	if (tip)
	394	return 1;
	395
d62a17ae	396	return 0;
718e3744	397	}
6b0655a2	398
d62a17ae	399	int bgp_multiaccess_check_v4(struct in_addr nexthop, struct peer *peer)
718e3744	400	{
d62a17ae	401	struct bgp_node *rn1;
	402	struct bgp_node *rn2;
	403	struct prefix p;
	404	int ret;
	405
	406	p.family = AF_INET;
	407	p.prefixlen = IPV4_MAX_BITLEN;
	408	p.u.prefix4 = nexthop;
	409
	410	rn1 = bgp_node_match(peer->bgp->connected_table[AFI_IP], &p);
	411	if (!rn1)
	412	return 0;
	413
	414	p.family = AF_INET;
	415	p.prefixlen = IPV4_MAX_BITLEN;
	416	p.u.prefix4 = peer->su.sin.sin_addr;
	417
	418	rn2 = bgp_node_match(peer->bgp->connected_table[AFI_IP], &p);
	419	if (!rn2) {
	420	bgp_unlock_node(rn1);
	421	return 0;
	422	}
718e3744	423
d62a17ae	424	ret = (rn1 == rn2) ? 1 : 0;
718e3744	425
d62a17ae	426	bgp_unlock_node(rn1);
d62a17ae	427	bgp_unlock_node(rn2);
718e3744	428
d62a17ae	429	return (ret);
718e3744	430	}
718e3744	431
65d4e0c6 DS	432	int bgp_subgrp_multiaccess_check_v4(struct in_addr nexthop,
	433	struct update_subgroup *subgrp)
	434	{
	435	struct bgp_node rn1, rn2;
	436	struct peer_af *paf;
	437	struct prefix p, np;
	438	struct bgp *bgp = NULL;
	439
	440	np.family = AF_INET;
	441	np.prefixlen = IPV4_MAX_BITLEN;
	442	np.u.prefix4 = nexthop;
	443
	444	p.family = AF_INET;
	445	p.prefixlen = IPV4_MAX_BITLEN;
	446
	447	rn1 = rn2 = NULL;
	448
	449	bgp = SUBGRP_INST(subgrp);
996c9314	450	rn1 = bgp_node_match(bgp->connected_table[AFI_IP], &np);
65d4e0c6 DS	451	if (!rn1)
	452	return 0;
	453
996c9314	454	SUBGRP_FOREACH_PEER (subgrp, paf) {
65d4e0c6 DS	455	p.u.prefix4 = paf->peer->su.sin.sin_addr;
65d4e0c6 DS	456
996c9314	457	rn2 = bgp_node_match(bgp->connected_table[AFI_IP], &p);
65d4e0c6 DS	458	if (rn1 == rn2) {
	459	bgp_unlock_node(rn1);
	460	bgp_unlock_node(rn2);
	461	return 1;
	462	}
	463
	464	if (rn2)
	465	bgp_unlock_node(rn2);
	466	}
	467
	468	bgp_unlock_node(rn1);
	469	return 0;
	470	}
	471
996c9314	472	static void bgp_show_nexthops_detail(struct vty vty, struct bgp bgp,
e22ac3ee DS	473	struct bgp_nexthop_cache *bnc)
	474	{
	475	char buf[PREFIX2STR_BUFFER];
	476	struct nexthop *nexthop;
	477
	478	for (nexthop = bnc->nexthop; nexthop; nexthop = nexthop->next)
	479	switch (nexthop->type) {
	480	case NEXTHOP_TYPE_IPV6:
	481	vty_out(vty, " gate %s\n",
996c9314 LB	482	inet_ntop(AF_INET6, &nexthop->gate.ipv6, buf,
996c9314 LB	483	sizeof(buf)));
e22ac3ee DS	484	break;
	485	case NEXTHOP_TYPE_IPV6_IFINDEX:
	486	vty_out(vty, " gate %s, if %s\n",
996c9314 LB	487	inet_ntop(AF_INET6, &nexthop->gate.ipv6, buf,
	488	sizeof(buf)),
	489	ifindex2ifname(nexthop->ifindex, bgp->vrf_id));
e22ac3ee DS	490	break;
	491	case NEXTHOP_TYPE_IPV4:
	492	vty_out(vty, " gate %s\n",
996c9314 LB	493	inet_ntop(AF_INET, &nexthop->gate.ipv4, buf,
996c9314 LB	494	sizeof(buf)));
e22ac3ee DS	495	break;
	496	case NEXTHOP_TYPE_IFINDEX:
	497	vty_out(vty, " if %s\n",
996c9314	498	ifindex2ifname(nexthop->ifindex, bgp->vrf_id));
e22ac3ee DS	499	break;
	500	case NEXTHOP_TYPE_IPV4_IFINDEX:
	501	vty_out(vty, " gate %s, if %s\n",
996c9314 LB	502	inet_ntop(AF_INET, &nexthop->gate.ipv4, buf,
	503	sizeof(buf)),
	504	ifindex2ifname(nexthop->ifindex, bgp->vrf_id));
e22ac3ee DS	505	break;
	506	case NEXTHOP_TYPE_BLACKHOLE:
	507	vty_out(vty, " blackhole\n");
	508	break;
	509	default:
996c9314	510	vty_out(vty, " invalid nexthop type %u\n",
e22ac3ee DS	511	nexthop->type);
	512	}
	513	}
	514
d62a17ae	515	static void bgp_show_nexthops(struct vty vty, struct bgp bgp, int detail)
fb018d25	516	{
d62a17ae	517	struct bgp_node *rn;
	518	struct bgp_nexthop_cache *bnc;
	519	char buf[PREFIX2STR_BUFFER];
d62a17ae	520	time_t tbuf;
	521	afi_t afi;
	522
	523	vty_out(vty, "Current BGP nexthop cache:\n");
	524	for (afi = AFI_IP; afi < AFI_MAX; afi++) {
	525	if (!bgp->nexthop_cache_table[afi])
	526	continue;
	527
	528	for (rn = bgp_table_top(bgp->nexthop_cache_table[afi]); rn;
	529	rn = bgp_route_next(rn)) {
	530	if ((bnc = rn->info) != NULL) {
	531	if (CHECK_FLAG(bnc->flags, BGP_NEXTHOP_VALID)) {
	532	vty_out(vty,
	533	" %s valid [IGP metric %d], #paths %d\n",
	534	inet_ntop(rn->p.family,
	535	&rn->p.u.prefix, buf,
	536	sizeof(buf)),
	537	bnc->metric, bnc->path_count);
e22ac3ee DS	538
	539	if (!detail)
	540	continue;
	541
	542	bgp_show_nexthops_detail(vty, bgp, bnc);
	543
996c9314	544	} else {
d62a17ae	545	vty_out(vty, " %s invalid\n",
	546	inet_ntop(rn->p.family,
	547	&rn->p.u.prefix, buf,
	548	sizeof(buf)));
	549	if (CHECK_FLAG(bnc->flags,
	550	BGP_NEXTHOP_CONNECTED))
	551	vty_out(vty,
	552	" Must be Connected\n");
	553	}
	554	tbuf = time(NULL)
	555	- (bgp_clock() - bnc->last_update);
	556	vty_out(vty, " Last update: %s", ctime(&tbuf));
	557	vty_out(vty, "\n");
da11a696 DS	558	}
da11a696 DS	559	}
fb018d25	560	}
f186de26	561	}
f186de26	562
d62a17ae	563	static int show_ip_bgp_nexthop_table(struct vty vty, const char name,
d62a17ae	564	int detail)
f186de26	565	{
d62a17ae	566	struct bgp *bgp;
	567
	568	if (name)
	569	bgp = bgp_lookup_by_name(name);
	570	else
	571	bgp = bgp_get_default();
	572	if (!bgp) {
	573	vty_out(vty, "%% No such BGP instance exist\n");
	574	return CMD_WARNING;
	575	}
f186de26	576
d62a17ae	577	bgp_show_nexthops(vty, bgp, detail);
f186de26	578
d62a17ae	579	return CMD_SUCCESS;
fb018d25 DS	580	}
fb018d25 DS	581
d62a17ae	582	static void bgp_show_all_instances_nexthops_vty(struct vty *vty)
f186de26	583	{
d62a17ae	584	struct listnode node, nnode;
	585	struct bgp *bgp;
	586
	587	for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
	588	vty_out(vty, "\nInstance %s:\n",
	589	(bgp->inst_type == BGP_INSTANCE_TYPE_DEFAULT)
	590	? "Default"
	591	: bgp->name);
	592	bgp_show_nexthops(vty, bgp, 0);
	593	}
f186de26	594	}
f186de26	595
fb018d25 DS	596	DEFUN (show_ip_bgp_nexthop,
fb018d25 DS	597	show_ip_bgp_nexthop_cmd,
18c57037	598	"show [ip] bgp [<view\|vrf> VIEWVRFNAME] nexthop [detail]",
50ef26d4	599	SHOW_STR
	600	IP_STR
	601	BGP_STR
8386ac43	602	BGP_INSTANCE_HELP_STR
3a2d747c QY	603	"BGP nexthop table\n"
3a2d747c QY	604	"Show detailed information\n")
50ef26d4	605	{
d62a17ae	606	int idx = 0;
b7ada628 DS	607	char *vrf = NULL;
	608
	609	if (argv_find(argv, argc, "view", &idx)
	610	\|\| argv_find(argv, argc, "vrf", &idx))
	611	vrf = argv[++idx]->arg;
d62a17ae	612	int detail = argv_find(argv, argc, "detail", &idx) ? 1 : 0;
d62a17ae	613	return show_ip_bgp_nexthop_table(vty, vrf, detail);
50ef26d4	614	}
50ef26d4	615
f186de26	616	DEFUN (show_ip_bgp_instance_all_nexthop,
f186de26	617	show_ip_bgp_instance_all_nexthop_cmd,
bec37ba5	618	"show [ip] bgp <view\|vrf> all nexthop",
f186de26	619	SHOW_STR
	620	IP_STR
	621	BGP_STR
	622	BGP_INSTANCE_ALL_HELP_STR
	623	"BGP nexthop table\n")
	624	{
d62a17ae	625	bgp_show_all_instances_nexthops_vty(vty);
d62a17ae	626	return CMD_SUCCESS;
f186de26	627	}
f186de26	628
d62a17ae	629	void bgp_scan_init(struct bgp *bgp)
718e3744	630	{
d62a17ae	631	afi_t afi;
	632
	633	for (afi = AFI_IP; afi < AFI_MAX; afi++) {
	634	bgp->nexthop_cache_table[afi] =
960035b2 PZ	635	bgp_table_init(bgp, afi, SAFI_UNICAST);
	636	bgp->connected_table[afi] = bgp_table_init(bgp, afi,
	637	SAFI_UNICAST);
d62a17ae	638	bgp->import_check_table[afi] =
960035b2	639	bgp_table_init(bgp, afi, SAFI_UNICAST);
d62a17ae	640	}
fc9a856f DS	641	}
fc9a856f DS	642
d62a17ae	643	void bgp_scan_vty_init(void)
fc9a856f	644	{
d62a17ae	645	install_element(VIEW_NODE, &show_ip_bgp_nexthop_cmd);
d62a17ae	646	install_element(VIEW_NODE, &show_ip_bgp_instance_all_nexthop_cmd);
718e3744	647	}
228da428	648
d62a17ae	649	void bgp_scan_finish(struct bgp *bgp)
228da428	650	{
d62a17ae	651	afi_t afi;
6c88b44d	652
d62a17ae	653	for (afi = AFI_IP; afi < AFI_MAX; afi++) {
	654	/* Only the current one needs to be reset. */
	655	bgp_nexthop_cache_reset(bgp->nexthop_cache_table[afi]);
	656	bgp_table_unlock(bgp->nexthop_cache_table[afi]);
	657	bgp->nexthop_cache_table[afi] = NULL;
228da428	658
d62a17ae	659	bgp_table_unlock(bgp->connected_table[afi]);
d62a17ae	660	bgp->connected_table[afi] = NULL;
078430f6	661
d62a17ae	662	bgp_table_unlock(bgp->import_check_table[afi]);
	663	bgp->import_check_table[afi] = NULL;
	664	}
228da428	665	}