0fea3d5165
kernel IPv6 multicast routing support. pim6 dense mode daemon pim6 sparse mode daemon netstat support of IPv6 multicast routing statistics Merging to the current and testing with other existing multicast routers is done by Tatsuya Jinmei <jinmei@kame.net>, who writes and maintainances the base code in KAME distribution. Make world check and kernel build check was also successful.
804 lines
24 KiB
C
804 lines
24 KiB
C
/*
|
|
* Copyright (c) 1998 by the University of Oregon.
|
|
* All rights reserved.
|
|
*
|
|
* Permission to use, copy, modify, and distribute this software and
|
|
* its documentation in source and binary forms for lawful
|
|
* purposes and without fee is hereby granted, provided
|
|
* that the above copyright notice appear in all copies and that both
|
|
* the copyright notice and this permission notice appear in supporting
|
|
* documentation, and that any documentation, advertising materials,
|
|
* and other materials related to such distribution and use acknowledge
|
|
* that the software was developed by the University of Oregon.
|
|
* The name of the University of Oregon may not be used to endorse or
|
|
* promote products derived from this software without specific prior
|
|
* written permission.
|
|
*
|
|
* THE UNIVERSITY OF OREGON DOES NOT MAKE ANY REPRESENTATIONS
|
|
* ABOUT THE SUITABILITY OF THIS SOFTWARE FOR ANY PURPOSE. THIS SOFTWARE IS
|
|
* PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,
|
|
* INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, TITLE, AND
|
|
* NON-INFRINGEMENT.
|
|
*
|
|
* IN NO EVENT SHALL UO, OR ANY OTHER CONTRIBUTOR BE LIABLE FOR ANY
|
|
* SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES, WHETHER IN CONTRACT,
|
|
* TORT, OR OTHER FORM OF ACTION, ARISING OUT OF OR IN CONNECTION WITH,
|
|
* THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*
|
|
* Other copyrights might apply to parts of this software and are so
|
|
* noted when applicable.
|
|
*/
|
|
/*
|
|
* Questions concerning this software should be directed to
|
|
* Kurt Windisch (kurtw@antc.uoregon.edu)
|
|
*
|
|
* $Id: mrt.c,v 1.2 1999/08/24 10:04:56 jinmei Exp $
|
|
*/
|
|
/*
|
|
* Part of this program has been derived from PIM sparse-mode pimd.
|
|
* The pimd program is covered by the license in the accompanying file
|
|
* named "LICENSE.pimd".
|
|
*
|
|
* The pimd program is COPYRIGHT 1998 by University of Southern California.
|
|
*
|
|
* Part of this program has been derived from mrouted.
|
|
* The mrouted program is covered by the license in the accompanying file
|
|
* named "LICENSE.mrouted".
|
|
*
|
|
* The mrouted program is COPYRIGHT 1989 by The Board of Trustees of
|
|
* Leland Stanford Junior University.
|
|
*
|
|
* $FreeBSD$
|
|
*/
|
|
|
|
#include "defs.h"
|
|
|
|
srcentry_t *srclist;
|
|
grpentry_t *grplist;
|
|
|
|
/*
|
|
* Local functions definition
|
|
*/
|
|
static srcentry_t *create_srcentry __P((struct sockaddr_in6 *source));
|
|
static int search_srclist __P((struct sockaddr_in6 *source,
|
|
srcentry_t **sourceEntry));
|
|
static int search_srcmrtlink __P((srcentry_t *srcentry_ptr,
|
|
struct sockaddr_in6 *group,
|
|
mrtentry_t **mrtPtr));
|
|
static void insert_srcmrtlink __P((mrtentry_t *elementPtr,
|
|
mrtentry_t *insertPtr,
|
|
srcentry_t *srcListPtr));
|
|
static grpentry_t *create_grpentry __P((struct sockaddr_in6 *group));
|
|
static int search_grplist __P((struct sockaddr_in6 *group,
|
|
grpentry_t **groupEntry));
|
|
static int search_grpmrtlink __P((grpentry_t *grpentry_ptr,
|
|
struct sockaddr_in6 *source,
|
|
mrtentry_t **mrtPtr));
|
|
static void insert_grpmrtlink __P((mrtentry_t *elementPtr,
|
|
mrtentry_t *insertPtr,
|
|
grpentry_t *grpListPtr));
|
|
static mrtentry_t *alloc_mrtentry __P((srcentry_t *srcentry_ptr,
|
|
grpentry_t *grpentry_ptr));
|
|
static mrtentry_t *create_mrtentry __P((srcentry_t *srcentry_ptr,
|
|
grpentry_t *grpentry_ptr,
|
|
u_int16 flags));
|
|
|
|
|
|
void
|
|
init_pim6_mrt()
|
|
{
|
|
|
|
/* TODO: delete any existing routing table */
|
|
|
|
/* Initialize the source list */
|
|
/* The first entry has the unspecified address and is not used */
|
|
/* The order is the smallest address first. */
|
|
srclist = (srcentry_t *)malloc(sizeof(srcentry_t));
|
|
srclist->next = (srcentry_t *)NULL;
|
|
srclist->prev = (srcentry_t *)NULL;
|
|
memset(&srclist->address, 0, sizeof(struct sockaddr_in6));
|
|
srclist->address.sin6_len = sizeof(struct sockaddr_in6);
|
|
srclist->address.sin6_family = AF_INET6;
|
|
srclist->mrtlink = (mrtentry_t *)NULL;
|
|
srclist->incoming = NO_VIF;
|
|
srclist->upstream = (pim_nbr_entry_t *)NULL;
|
|
srclist->metric = 0;
|
|
srclist->preference = 0;
|
|
srclist->timer = 0;
|
|
|
|
/* Initialize the group list */
|
|
/* The first entry has the unspecified address and is not used */
|
|
/* The order is the smallest address first. */
|
|
grplist = (grpentry_t *)malloc(sizeof(grpentry_t));
|
|
grplist->next = (grpentry_t *)NULL;
|
|
grplist->prev = (grpentry_t *)NULL;
|
|
memset(&grplist->group, 0, sizeof(struct sockaddr_in6));
|
|
grplist->group.sin6_len = sizeof(struct sockaddr_in6);
|
|
grplist->group.sin6_family = AF_INET6;
|
|
grplist->mrtlink = (mrtentry_t *)NULL;
|
|
}
|
|
|
|
|
|
grpentry_t*
|
|
find_group(group)
|
|
struct sockaddr_in6 *group;
|
|
{
|
|
grpentry_t *grpentry_ptr;
|
|
|
|
if (!IN6_IS_ADDR_MULTICAST(&group->sin6_addr))
|
|
return (grpentry_t *)NULL;
|
|
|
|
if (search_grplist(group, &grpentry_ptr) == TRUE) {
|
|
/* Group found! */
|
|
return (grpentry_ptr);
|
|
}
|
|
return (grpentry_t *)NULL;
|
|
}
|
|
|
|
|
|
srcentry_t *
|
|
find_source(source)
|
|
struct sockaddr_in6 *source;
|
|
{
|
|
srcentry_t *srcentry_ptr;
|
|
|
|
if (!inet6_valid_host(source))
|
|
return (srcentry_t *)NULL;
|
|
|
|
if (search_srclist(source, &srcentry_ptr) == TRUE) {
|
|
/* Source found! */
|
|
return (srcentry_ptr);
|
|
}
|
|
return (srcentry_t *)NULL;
|
|
}
|
|
|
|
|
|
mrtentry_t *
|
|
find_route(source, group, flags, create)
|
|
struct sockaddr_in6 *source, *group;
|
|
u_int16 flags;
|
|
char create;
|
|
{
|
|
srcentry_t *srcentry_ptr;
|
|
grpentry_t *grpentry_ptr;
|
|
mrtentry_t *mrtentry_ptr;
|
|
|
|
if (!IN6_IS_ADDR_MULTICAST(&group->sin6_addr))
|
|
return (mrtentry_t *)NULL;
|
|
|
|
if (!inet6_valid_host(source))
|
|
return (mrtentry_t *)NULL;
|
|
|
|
if (create == DONT_CREATE) {
|
|
if (search_grplist(group, &grpentry_ptr) == FALSE)
|
|
return (mrtentry_t *)NULL;
|
|
/* Search for the source */
|
|
if (search_grpmrtlink(grpentry_ptr, source,
|
|
&mrtentry_ptr) == TRUE) {
|
|
/* Exact (S,G) entry found */
|
|
return (mrtentry_ptr);
|
|
}
|
|
return (mrtentry_t *)NULL;
|
|
}
|
|
|
|
|
|
/* Creation allowed */
|
|
|
|
grpentry_ptr = create_grpentry(group);
|
|
if (grpentry_ptr == (grpentry_t *)NULL) {
|
|
return (mrtentry_t *)NULL;
|
|
}
|
|
|
|
/* Setup the (S,G) routing entry */
|
|
srcentry_ptr = create_srcentry(source);
|
|
if (srcentry_ptr == (srcentry_t *)NULL) {
|
|
if (grpentry_ptr->mrtlink == (mrtentry_t *)NULL) {
|
|
/* New created grpentry. Delete it. */
|
|
delete_grpentry(grpentry_ptr);
|
|
}
|
|
return (mrtentry_t *)NULL;
|
|
}
|
|
|
|
mrtentry_ptr = create_mrtentry(srcentry_ptr, grpentry_ptr, MRTF_SG);
|
|
if (mrtentry_ptr == (mrtentry_t *)NULL) {
|
|
if (grpentry_ptr->mrtlink == (mrtentry_t *)NULL) {
|
|
/* New created grpentry. Delete it. */
|
|
delete_grpentry(grpentry_ptr);
|
|
}
|
|
if (srcentry_ptr->mrtlink == (mrtentry_t *)NULL) {
|
|
/* New created srcentry. Delete it. */
|
|
delete_srcentry(srcentry_ptr);
|
|
}
|
|
return (mrtentry_t *)NULL;
|
|
}
|
|
|
|
if (mrtentry_ptr->flags & MRTF_NEW) {
|
|
struct mrtfilter *f;
|
|
/* The mrtentry pref/metric should be the pref/metric of the
|
|
* _upstream_ assert winner. Since this isn't known now,
|
|
* set it to the config'ed default
|
|
*/
|
|
mrtentry_ptr->incoming = srcentry_ptr->incoming;
|
|
mrtentry_ptr->upstream = srcentry_ptr->upstream;
|
|
mrtentry_ptr->metric = srcentry_ptr->metric;
|
|
mrtentry_ptr->preference = srcentry_ptr->preference;
|
|
|
|
if ((f = search_filter(&group->sin6_addr)))
|
|
IF_COPY(&f->ifset, &mrtentry_ptr->filter_oifs);
|
|
}
|
|
|
|
return (mrtentry_ptr);
|
|
}
|
|
|
|
|
|
void
|
|
delete_srcentry(srcentry_ptr)
|
|
srcentry_t *srcentry_ptr;
|
|
{
|
|
mrtentry_t *mrtentry_ptr;
|
|
mrtentry_t *mrtentry_next;
|
|
|
|
if (srcentry_ptr == (srcentry_t *)NULL)
|
|
return;
|
|
/* TODO: XXX: the first entry is unused and always there */
|
|
srcentry_ptr->prev->next = srcentry_ptr->next;
|
|
if (srcentry_ptr->next != (srcentry_t *)NULL)
|
|
srcentry_ptr->next->prev = srcentry_ptr->prev;
|
|
|
|
for (mrtentry_ptr = srcentry_ptr->mrtlink;
|
|
mrtentry_ptr != (mrtentry_t *)NULL;
|
|
mrtentry_ptr = mrtentry_next) {
|
|
mrtentry_next = mrtentry_ptr->srcnext;
|
|
if (mrtentry_ptr->grpprev != (mrtentry_t *)NULL)
|
|
mrtentry_ptr->grpprev->grpnext = mrtentry_ptr->grpnext;
|
|
else {
|
|
mrtentry_ptr->group->mrtlink = mrtentry_ptr->grpnext;
|
|
if (mrtentry_ptr->grpnext == (mrtentry_t *)NULL) {
|
|
/* Delete the group entry */
|
|
delete_grpentry(mrtentry_ptr->group);
|
|
}
|
|
}
|
|
if (mrtentry_ptr->grpnext != (mrtentry_t *)NULL)
|
|
mrtentry_ptr->grpnext->grpprev = mrtentry_ptr->grpprev;
|
|
FREE_MRTENTRY(mrtentry_ptr);
|
|
}
|
|
free((char *)srcentry_ptr);
|
|
}
|
|
|
|
|
|
void
|
|
delete_grpentry(grpentry_ptr)
|
|
grpentry_t *grpentry_ptr;
|
|
{
|
|
mrtentry_t *mrtentry_ptr;
|
|
mrtentry_t *mrtentry_next;
|
|
|
|
if (grpentry_ptr == (grpentry_t *)NULL)
|
|
return;
|
|
/* TODO: XXX: the first entry is unused and always there */
|
|
grpentry_ptr->prev->next = grpentry_ptr->next;
|
|
if (grpentry_ptr->next != (grpentry_t *)NULL)
|
|
grpentry_ptr->next->prev = grpentry_ptr->prev;
|
|
|
|
for (mrtentry_ptr = grpentry_ptr->mrtlink;
|
|
mrtentry_ptr != (mrtentry_t *)NULL;
|
|
mrtentry_ptr = mrtentry_next) {
|
|
mrtentry_next = mrtentry_ptr->grpnext;
|
|
if (mrtentry_ptr->srcprev != (mrtentry_t *)NULL)
|
|
mrtentry_ptr->srcprev->srcnext = mrtentry_ptr->srcnext;
|
|
else {
|
|
mrtentry_ptr->source->mrtlink = mrtentry_ptr->srcnext;
|
|
if (mrtentry_ptr->srcnext == (mrtentry_t *)NULL) {
|
|
/* Delete the srcentry if this was the last routing entry */
|
|
delete_srcentry(mrtentry_ptr->source);
|
|
}
|
|
}
|
|
if (mrtentry_ptr->srcnext != (mrtentry_t *)NULL)
|
|
mrtentry_ptr->srcnext->srcprev = mrtentry_ptr->srcprev;
|
|
FREE_MRTENTRY(mrtentry_ptr);
|
|
}
|
|
free((char *)grpentry_ptr);
|
|
}
|
|
|
|
|
|
void
|
|
delete_mrtentry(mrtentry_ptr)
|
|
mrtentry_t *mrtentry_ptr;
|
|
{
|
|
if (mrtentry_ptr == (mrtentry_t *)NULL)
|
|
return;
|
|
|
|
/* Delete the kernel cache first */
|
|
k_del_mfc(mld6_socket, &mrtentry_ptr->source->address,
|
|
&mrtentry_ptr->group->group);
|
|
|
|
#ifdef RSRR
|
|
/* Tell the reservation daemon */
|
|
rsrr_cache_clean(mrtentry_ptr);
|
|
#endif /* RSRR */
|
|
|
|
/* (S,G) mrtentry */
|
|
/* Delete from the grpentry MRT chain */
|
|
if (mrtentry_ptr->grpprev != (mrtentry_t *)NULL)
|
|
mrtentry_ptr->grpprev->grpnext = mrtentry_ptr->grpnext;
|
|
else {
|
|
mrtentry_ptr->group->mrtlink = mrtentry_ptr->grpnext;
|
|
if (mrtentry_ptr->grpnext == (mrtentry_t *)NULL) {
|
|
/* Delete the group entry */
|
|
delete_grpentry(mrtentry_ptr->group);
|
|
}
|
|
}
|
|
|
|
if (mrtentry_ptr->grpnext != (mrtentry_t *)NULL)
|
|
mrtentry_ptr->grpnext->grpprev = mrtentry_ptr->grpprev;
|
|
|
|
/* Delete from the srcentry MRT chain */
|
|
if (mrtentry_ptr->srcprev != (mrtentry_t *)NULL)
|
|
mrtentry_ptr->srcprev->srcnext = mrtentry_ptr->srcnext;
|
|
else {
|
|
mrtentry_ptr->source->mrtlink = mrtentry_ptr->srcnext;
|
|
if (mrtentry_ptr->srcnext == (mrtentry_t *)NULL) {
|
|
/* Delete the srcentry if this was the last routing entry */
|
|
delete_srcentry(mrtentry_ptr->source);
|
|
}
|
|
}
|
|
if (mrtentry_ptr->srcnext != (mrtentry_t *)NULL)
|
|
mrtentry_ptr->srcnext->srcprev = mrtentry_ptr->srcprev;
|
|
|
|
FREE_MRTENTRY(mrtentry_ptr);
|
|
}
|
|
|
|
|
|
static int
|
|
search_srclist(source, sourceEntry)
|
|
struct sockaddr_in6 *source;
|
|
register srcentry_t **sourceEntry;
|
|
{
|
|
register srcentry_t *s_prev,*s;
|
|
|
|
for (s_prev = srclist, s = s_prev->next; s != (srcentry_t *)NULL;
|
|
s_prev = s, s = s->next) {
|
|
/* The srclist is ordered with the smallest addresses first.
|
|
* The first entry is not used.
|
|
*/
|
|
if (inet6_lessthan(&s->address, source))
|
|
continue;
|
|
if (inet6_equal(&s->address, source)) {
|
|
*sourceEntry = s;
|
|
return(TRUE);
|
|
}
|
|
break;
|
|
}
|
|
*sourceEntry = s_prev; /* The insertion point is between s_prev and s */
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
static int
|
|
search_grplist(group, groupEntry)
|
|
struct sockaddr_in6 *group;
|
|
register grpentry_t **groupEntry;
|
|
{
|
|
register grpentry_t *g_prev, *g;
|
|
|
|
for (g_prev = grplist, g = g_prev->next; g != (grpentry_t *)NULL;
|
|
g_prev = g, g = g->next) {
|
|
/* The grplist is ordered with the smallest address first.
|
|
* The first entry is not used.
|
|
*/
|
|
if (inet6_lessthan(&g->group, group))
|
|
continue;
|
|
if (inet6_equal(&g->group, group)) {
|
|
*groupEntry = g;
|
|
return(TRUE);
|
|
}
|
|
break;
|
|
}
|
|
*groupEntry = g_prev; /* The insertion point is between g_prev and g */
|
|
return(FALSE);
|
|
}
|
|
|
|
static srcentry_t *
|
|
create_srcentry(source)
|
|
struct sockaddr_in6 *source;
|
|
{
|
|
register srcentry_t *srcentry_ptr;
|
|
srcentry_t *srcentry_prev;
|
|
|
|
if (search_srclist(source, &srcentry_prev) == TRUE)
|
|
return (srcentry_prev);
|
|
|
|
srcentry_ptr = (srcentry_t *)malloc(sizeof(srcentry_t));
|
|
if (srcentry_ptr == (srcentry_t *)NULL) {
|
|
log(LOG_WARNING, 0, "Memory allocation error for srcentry %s",
|
|
inet6_fmt(&source->sin6_addr));
|
|
return (srcentry_t *)NULL;
|
|
}
|
|
|
|
srcentry_ptr->address = *source;
|
|
/*
|
|
* Free the memory if there is error getting the iif and
|
|
* the next hop (upstream) router.
|
|
*/
|
|
if (set_incoming(srcentry_ptr, PIM_IIF_SOURCE) == FALSE) {
|
|
free((char *)srcentry_ptr);
|
|
return (srcentry_t *)NULL;
|
|
}
|
|
srcentry_ptr->mrtlink = (mrtentry_t *)NULL;
|
|
srcentry_ptr->timer = 0;
|
|
srcentry_ptr->next = srcentry_prev->next;
|
|
srcentry_prev->next = srcentry_ptr;
|
|
srcentry_ptr->prev = srcentry_prev;
|
|
if (srcentry_ptr->next != (srcentry_t *)NULL)
|
|
srcentry_ptr->next->prev = srcentry_ptr;
|
|
|
|
IF_DEBUG(DEBUG_MFC)
|
|
log(LOG_DEBUG, 0, "create source entry, source %s",
|
|
inet6_fmt(&source->sin6_addr));
|
|
return (srcentry_ptr);
|
|
}
|
|
|
|
|
|
static grpentry_t *
|
|
create_grpentry(group)
|
|
struct sockaddr_in6 *group;
|
|
{
|
|
register grpentry_t *grpentry_ptr;
|
|
grpentry_t *grpentry_prev;
|
|
|
|
if (search_grplist(group, &grpentry_prev) == TRUE)
|
|
return (grpentry_prev);
|
|
|
|
grpentry_ptr = (grpentry_t *)malloc(sizeof(grpentry_t));
|
|
if (grpentry_ptr == (grpentry_t *)NULL) {
|
|
log(LOG_WARNING, 0, "Memory allocation error for grpentry %s",
|
|
inet6_fmt(&group->sin6_addr));
|
|
return (grpentry_t *)NULL;
|
|
}
|
|
|
|
grpentry_ptr->group = *group;
|
|
grpentry_ptr->mrtlink = (mrtentry_t *)NULL;
|
|
|
|
/* Now it is safe to include the new group entry */
|
|
grpentry_ptr->next = grpentry_prev->next;
|
|
grpentry_prev->next = grpentry_ptr;
|
|
grpentry_ptr->prev = grpentry_prev;
|
|
if (grpentry_ptr->next != (grpentry_t *)NULL)
|
|
grpentry_ptr->next->prev = grpentry_ptr;
|
|
|
|
IF_DEBUG(DEBUG_MFC)
|
|
log(LOG_DEBUG, 0, "create group entry, group %s",
|
|
inet6_fmt(&group->sin6_addr));
|
|
return(grpentry_ptr);
|
|
}
|
|
|
|
|
|
/*
|
|
* Return TRUE if the entry is found and then *mrtPtr is set to point to that
|
|
* entry. Otherwise return FALSE and *mrtPtr points the the previous entry
|
|
* (or NULL if first in the chain.
|
|
*/
|
|
static int
|
|
search_srcmrtlink(srcentry_ptr, group, mrtPtr)
|
|
srcentry_t *srcentry_ptr;
|
|
struct sockaddr_in6 *group;
|
|
mrtentry_t **mrtPtr;
|
|
{
|
|
register mrtentry_t *mrtentry_ptr;
|
|
register mrtentry_t *m_prev = (mrtentry_t *)NULL;
|
|
|
|
for(mrtentry_ptr = srcentry_ptr->mrtlink;
|
|
mrtentry_ptr != (mrtentry_t *)NULL;
|
|
m_prev = mrtentry_ptr, mrtentry_ptr = mrtentry_ptr->srcnext) {
|
|
/* The entries are ordered with the smaller group address first.
|
|
* The addresses are in network order.
|
|
*/
|
|
if (inet6_lessthan(&mrtentry_ptr->group->group, group))
|
|
continue;
|
|
if (inet6_equal(&mrtentry_ptr->group->group, group)) {
|
|
*mrtPtr = mrtentry_ptr;
|
|
return(TRUE);
|
|
}
|
|
break;
|
|
}
|
|
*mrtPtr = m_prev;
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
/*
|
|
* Return TRUE if the entry is found and then *mrtPtr is set to point to that
|
|
* entry. Otherwise return FALSE and *mrtPtr points the the previous entry
|
|
* (or NULL if first in the chain.
|
|
*/
|
|
static int
|
|
search_grpmrtlink(grpentry_ptr, source, mrtPtr)
|
|
grpentry_t *grpentry_ptr;
|
|
struct sockaddr_in6 *source;
|
|
mrtentry_t **mrtPtr;
|
|
{
|
|
register mrtentry_t *mrtentry_ptr;
|
|
register mrtentry_t *m_prev = (mrtentry_t *)NULL;
|
|
|
|
for (mrtentry_ptr = grpentry_ptr->mrtlink;
|
|
mrtentry_ptr != (mrtentry_t *)NULL;
|
|
m_prev = mrtentry_ptr, mrtentry_ptr = mrtentry_ptr->grpnext) {
|
|
/* The entries are ordered with the smaller source address first.
|
|
* The addresses are in network order.
|
|
*/
|
|
if (inet6_lessthan(&mrtentry_ptr->source->address, source))
|
|
continue;
|
|
if (inet6_equal(source, &mrtentry_ptr->source->address)) {
|
|
*mrtPtr = mrtentry_ptr;
|
|
return(TRUE);
|
|
}
|
|
break;
|
|
}
|
|
*mrtPtr = m_prev;
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
static void
|
|
insert_srcmrtlink(mrtentry_new, mrtentry_prev, srcentry_ptr)
|
|
mrtentry_t *mrtentry_new;
|
|
mrtentry_t *mrtentry_prev;
|
|
srcentry_t *srcentry_ptr;
|
|
{
|
|
if (mrtentry_prev == (mrtentry_t *)NULL) {
|
|
/* Has to be insert as the head entry for this source */
|
|
mrtentry_new->srcnext = srcentry_ptr->mrtlink;
|
|
mrtentry_new->srcprev = (mrtentry_t *)NULL;
|
|
srcentry_ptr->mrtlink = mrtentry_new;
|
|
}
|
|
else {
|
|
/* Insert right after the mrtentry_prev */
|
|
mrtentry_new->srcnext = mrtentry_prev->srcnext;
|
|
mrtentry_new->srcprev = mrtentry_prev;
|
|
mrtentry_prev->srcnext = mrtentry_new;
|
|
}
|
|
if (mrtentry_new->srcnext != (mrtentry_t *)NULL)
|
|
mrtentry_new->srcnext->srcprev = mrtentry_new;
|
|
}
|
|
|
|
|
|
static void
|
|
insert_grpmrtlink(mrtentry_new, mrtentry_prev, grpentry_ptr)
|
|
mrtentry_t *mrtentry_new;
|
|
mrtentry_t *mrtentry_prev;
|
|
grpentry_t *grpentry_ptr;
|
|
{
|
|
if (mrtentry_prev == (mrtentry_t *)NULL) {
|
|
/* Has to be insert as the head entry for this group */
|
|
mrtentry_new->grpnext = grpentry_ptr->mrtlink;
|
|
mrtentry_new->grpprev = (mrtentry_t *)NULL;
|
|
grpentry_ptr->mrtlink = mrtentry_new;
|
|
}
|
|
else {
|
|
/* Insert right after the mrtentry_prev */
|
|
mrtentry_new->grpnext = mrtentry_prev->grpnext;
|
|
mrtentry_new->grpprev = mrtentry_prev;
|
|
mrtentry_prev->grpnext = mrtentry_new;
|
|
}
|
|
if (mrtentry_new->grpnext != (mrtentry_t *)NULL)
|
|
mrtentry_new->grpnext->grpprev = mrtentry_new;
|
|
}
|
|
|
|
|
|
static mrtentry_t *
|
|
alloc_mrtentry(srcentry_ptr, grpentry_ptr)
|
|
srcentry_t *srcentry_ptr;
|
|
grpentry_t *grpentry_ptr;
|
|
{
|
|
register mrtentry_t *mrtentry_ptr;
|
|
u_int16 i, *i_ptr;
|
|
u_long *il_ptr;
|
|
u_int8 vif_numbers;
|
|
|
|
mrtentry_ptr = (mrtentry_t *)malloc(sizeof(mrtentry_t));
|
|
if (mrtentry_ptr == (mrtentry_t *)NULL) {
|
|
log(LOG_WARNING, 0, "alloc_mrtentry(): out of memory");
|
|
return (mrtentry_t *)NULL;
|
|
}
|
|
|
|
/*
|
|
* grpnext, grpprev, srcnext, srcprev will be setup when we link the
|
|
* mrtentry to the source and group chains
|
|
*/
|
|
mrtentry_ptr->source = srcentry_ptr;
|
|
mrtentry_ptr->group = grpentry_ptr;
|
|
mrtentry_ptr->incoming = NO_VIF;
|
|
IF_ZERO(&mrtentry_ptr->leaves);
|
|
IF_ZERO(&mrtentry_ptr->pruned_oifs);
|
|
IF_ZERO(&mrtentry_ptr->oifs);
|
|
IF_ZERO(&mrtentry_ptr->filter_oifs);
|
|
IF_ZERO(&mrtentry_ptr->asserted_oifs);
|
|
mrtentry_ptr->upstream = (pim_nbr_entry_t *)NULL;
|
|
mrtentry_ptr->metric = 0;
|
|
mrtentry_ptr->preference = 0;
|
|
#ifdef RSRR
|
|
mrtentry_ptr->rsrr_cache = (struct rsrr_cache *)NULL;
|
|
#endif /* RSRR */
|
|
|
|
/*
|
|
* XXX: TODO: if we are short in memory, we can reserve as few as possible
|
|
* space for vif timers (per group and/or routing entry), but then everytime
|
|
* when a new interfaces is configured, the router will be restarted and
|
|
* will delete the whole routing table. The "memory is cheap" solution is
|
|
* to reserve timer space for all potential vifs in advance and then no
|
|
* need to delete the routing table and disturb the forwarding.
|
|
*/
|
|
#ifdef SAVE_MEMORY
|
|
mrtentry_ptr->prune_timers = (u_int16 *)malloc(sizeof(u_int16) * numvifs);
|
|
mrtentry_ptr->prune_delay_timerids =
|
|
(u_long *)malloc(sizeof(u_long) * numvifs);
|
|
mrtentry_ptr->last_assert = (u_long *)malloc(sizeof(u_long) * numvifs);
|
|
mrtentry_ptr->last_prune = (u_long *)malloc(sizeof(u_long) * numvifs);
|
|
vif_numbers = numvifs;
|
|
#else
|
|
mrtentry_ptr->prune_timers =
|
|
(u_int16 *)malloc(sizeof(u_int16) * total_interfaces);
|
|
mrtentry_ptr->prune_delay_timerids =
|
|
(u_long *)malloc(sizeof(u_long) * total_interfaces);
|
|
mrtentry_ptr->last_assert =
|
|
(u_long *)malloc(sizeof(u_long) * total_interfaces);
|
|
mrtentry_ptr->last_prune =
|
|
(u_long *)malloc(sizeof(u_long) * total_interfaces);
|
|
vif_numbers = total_interfaces;
|
|
#endif /* SAVE_MEMORY */
|
|
if ((mrtentry_ptr->prune_timers == (u_int16 *)NULL) ||
|
|
(mrtentry_ptr->prune_delay_timerids == (u_long *)NULL) ||
|
|
(mrtentry_ptr->last_assert == (u_long *)NULL) ||
|
|
(mrtentry_ptr->last_prune == (u_long *)NULL)) {
|
|
log(LOG_WARNING, 0, "alloc_mrtentry(): out of memory");
|
|
FREE_MRTENTRY(mrtentry_ptr);
|
|
return (mrtentry_t *)NULL;
|
|
}
|
|
/* Reset the timers */
|
|
for (i = 0, i_ptr = mrtentry_ptr->prune_timers; i < vif_numbers;
|
|
i++, i_ptr++)
|
|
*i_ptr = 0;
|
|
for (i = 0, il_ptr = mrtentry_ptr->prune_delay_timerids; i < vif_numbers;
|
|
i++, il_ptr++)
|
|
*il_ptr = 0;
|
|
for (i = 0, il_ptr = mrtentry_ptr->last_assert; i < vif_numbers;
|
|
i++, il_ptr++)
|
|
*il_ptr = 0;
|
|
for (i = 0, il_ptr = mrtentry_ptr->last_prune; i < vif_numbers;
|
|
i++, il_ptr++)
|
|
*il_ptr = 0;
|
|
|
|
mrtentry_ptr->flags = MRTF_NEW;
|
|
mrtentry_ptr->timer = 0;
|
|
mrtentry_ptr->join_delay_timerid = 0;
|
|
mrtentry_ptr->assert_timer = 0;
|
|
mrtentry_ptr->graft = (pim_graft_entry_t *)NULL;
|
|
|
|
return(mrtentry_ptr);
|
|
}
|
|
|
|
|
|
static mrtentry_t *
|
|
create_mrtentry(srcentry_ptr, grpentry_ptr, flags)
|
|
srcentry_t *srcentry_ptr;
|
|
grpentry_t *grpentry_ptr;
|
|
u_int16 flags;
|
|
{
|
|
mrtentry_t *r_new;
|
|
mrtentry_t *r_grp_insert, *r_src_insert; /* pointers to insert */
|
|
struct sockaddr_in6 *source;
|
|
struct sockaddr_in6 *group;
|
|
|
|
/* (S,G) entry */
|
|
source = &srcentry_ptr->address;
|
|
group = &grpentry_ptr->group;
|
|
|
|
if (search_grpmrtlink(grpentry_ptr, source, &r_grp_insert) == TRUE) {
|
|
return(r_grp_insert);
|
|
}
|
|
if (search_srcmrtlink(srcentry_ptr, group, &r_src_insert) == TRUE) {
|
|
/*
|
|
* Hmmm, search_grpmrtlink() didn't find the entry, but
|
|
* search_srcmrtlink() did find it! Shoudn't happen. Panic!
|
|
*/
|
|
log(LOG_ERR, 0, "MRT inconsistency for src %s and grp %s\n",
|
|
inet6_fmt(&source->sin6_addr), inet6_fmt(&group->sin6_addr));
|
|
/* not reached but to make lint happy */
|
|
return (mrtentry_t *)NULL;
|
|
}
|
|
/*
|
|
* Create and insert in group mrtlink and source mrtlink chains.
|
|
*/
|
|
r_new = alloc_mrtentry(srcentry_ptr, grpentry_ptr);
|
|
if (r_new == (mrtentry_t *)NULL)
|
|
return (mrtentry_t *)NULL;
|
|
/*
|
|
* r_new has to be insert right after r_grp_insert in the
|
|
* grp mrtlink chain and right after r_src_insert in the
|
|
* src mrtlink chain
|
|
*/
|
|
insert_grpmrtlink(r_new, r_grp_insert, grpentry_ptr);
|
|
insert_srcmrtlink(r_new, r_src_insert, srcentry_ptr);
|
|
r_new->flags |= MRTF_SG;
|
|
return (r_new);
|
|
}
|
|
|
|
/* ======================== */
|
|
/* filter related functions */
|
|
struct mrtfilter *filterlist;
|
|
|
|
/*
|
|
* Search for a filter entry in the filter list.
|
|
*/
|
|
struct mrtfilter *
|
|
search_filter(maddr)
|
|
struct in6_addr *maddr;
|
|
{
|
|
struct mrtfilter *f;
|
|
struct sockaddr_in6 msa6;
|
|
|
|
for (f = filterlist; f; f = f->next) {
|
|
switch(f->type) {
|
|
case FILTER_RANGE:
|
|
msa6.sin6_scope_id = 0; /* XXX: scope consideration */
|
|
msa6.sin6_addr = *maddr;
|
|
if (inet6_greateroreq(&msa6, &f->mrtf_from) &&
|
|
inet6_lessoreq(&msa6, &f->mrtf_to))
|
|
return(f);
|
|
break;
|
|
case FILTER_PREFIX:
|
|
msa6.sin6_scope_id = 0; /* XXX: scope consideration */
|
|
if (inet6_match_prefix(&msa6, &f->mrtf_prefix,
|
|
&f->mrtf_mask))
|
|
return(f);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return(NULL);
|
|
}
|
|
|
|
/*
|
|
* Make a new filter entry.
|
|
* This function assumes
|
|
*/
|
|
struct mrtfilter *
|
|
add_filter(type, maddr1, maddr2, plen)
|
|
struct in6_addr *maddr1, *maddr2;
|
|
int type, plen;
|
|
{
|
|
struct mrtfilter *f;
|
|
struct sockaddr_in6 from, to;
|
|
|
|
if ((f = malloc(sizeof(*f))) == NULL)
|
|
log(LOG_ERR, 0, "add_filter: malloc failed"); /* assert */
|
|
memset((void *)f, 0, sizeof(*f));
|
|
|
|
f->type = type;
|
|
switch(type) {
|
|
case FILTER_RANGE:
|
|
memset((void *)&from, 0, sizeof(from));
|
|
memset((void *)&to, 0, sizeof(to));
|
|
from.sin6_addr = *maddr1;
|
|
to.sin6_addr = *maddr2;
|
|
if (inet6_lessthan(&from, &to)) {
|
|
f->mrtf_from = from;
|
|
f->mrtf_to = to;
|
|
}
|
|
else {
|
|
f->mrtf_from = to;
|
|
f->mrtf_to = from;
|
|
}
|
|
break;
|
|
case FILTER_PREFIX:
|
|
f->mrtf_prefix.sin6_addr = *maddr1;
|
|
MASKLEN_TO_MASK6(plen, f->mrtf_mask);
|
|
break;
|
|
}
|
|
f->next = filterlist;
|
|
filterlist = f;
|
|
|
|
return(f);
|
|
}
|