path: root/usr.sbin/pim6sd/pim6_proto.c

/*
 * Copyright (C) 1999 LSIIT Laboratory.
 * All rights reserved.
 *
 * 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.
 * 3. Neither the name of the project nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE PROJECT 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 PROJECT 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.
 */
/*
 * Copyright (C) 1998 WIDE Project.
 * All rights reserved.
 *
 * 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.
 * 3. Neither the name of the project nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE PROJECT 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 PROJECT 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.
 */
/*
 *  Copyright (c) 1998 by the University of Southern California.
 *  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 Southern
 *  California and/or Information Sciences Institute.
 *  The name of the University of Southern California may not
 *  be used to endorse or promote products derived from this software
 *  without specific prior written permission.
 *
 *  THE UNIVERSITY OF SOUTHERN CALIFORNIA 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 USC, 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.
 *
 * $FreeBSD$
 */
/*
 *  Questions concerning this software should be directed to
 *  Mickael Hoerdt (hoerdt@clarinet.u-strasbg.fr) LSIIT Strasbourg.
 *
 */
/*
 * This program has been derived from pim6dd.
 * The pim6dd program is covered by the license in the accompanying file
 * named "LICENSE.pim6dd".
 */
/*
 * This program has been derived from pimd.
 * The pimd program is covered by the license in the accompanying file
 * named "LICENSE.pimd".
 *
 */

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet6/pim6.h>
#include <netinet/ip6.h>
#include <syslog.h>
#include <stdlib.h>
#include "mrt.h"
#include "defs.h"
#include "vif.h"
#include "debug.h"
#include "pim6.h"
#include "pim6_proto.h"
#include "pimd.h"
#include "rp.h"
#include "mld6.h"
#include "timer.h"
#include "route.h"
#include "inet6.h"
#include "kern.h"
#include "routesock.h"

/*
 * Local functions definitions.
 */

static int parse_pim6_hello 			__P((char *pktPtr , int datalen , struct sockaddr_in6 *src,
						     u_int16 *holdtime));

static int send_pim6_register_stop 		__P((struct sockaddr_in6 *reg_src , struct sockaddr_in6 *reg_dst ,
	                       		     	     struct sockaddr_in6 *inner_source,
		                	             struct sockaddr_in6 *inner_grp));

static build_jp_message_t *get_jp6_working_buff __P(());
static void return_jp6_working_buff 		__P((pim_nbr_entry_t * pim_nbr));
static void pack_jp6_message 			__P((pim_nbr_entry_t * pim_nbr));
static void send_jp6_message 			__P((pim_nbr_entry_t * pim_nbr));
static int compare_metrics 			__P((u_int32 local_preference,
		                		     u_int32 local_metric,
		                		     struct sockaddr_in6 *local_address,
		                		     u_int32 remote_preference,
		                		     u_int32 remote_metric,
		                		     struct sockaddr_in6 *remote_address));

build_jp_message_t 	*build_jp_message_pool;
int			build_jp_message_pool_counter;
struct sockaddr_in6 sockaddr6_any = {sizeof(struct sockaddr_in6) , AF_INET6 ,0,0, IN6ADDR_ANY_INIT};
struct sockaddr_in6 sockaddr6_d;

struct pim6dstat pim6dstat;

/************************************************************************
 *                        PIM_HELLO
 ************************************************************************/
int
receive_pim6_hello(src, pim_message, datalen)
    struct sockaddr_in6 *src;
    register char       *pim_message;
    int                 datalen;
{
    mifi_t			mifi;
    struct uvif    		*v;
    register pim_nbr_entry_t 	*nbr,
                   		*prev_nbr,
                   		*new_nbr;
    u_int16         		holdtime;
    int             		bsr_length;
    u_int8         		*data_ptr;
    srcentry_t     		*srcentry_ptr;
    mrtentry_t     		*mrtentry_ptr;


    if ((mifi = find_vif_direct(src)) == NO_VIF)
    {
	/*
	 * Either a local vif or somehow received PIM_HELLO from non-directly
	 * connected router. Ignore it.
	 */

	if (local_address(src) == NO_VIF)
	    log(LOG_INFO, 0, "Ignoring PIM_HELLO from non-neighbor router %s",
		inet6_fmt(&src->sin6_addr));
	return (FALSE);
    }

    v = &uvifs[mifi];
    v->uv_in_pim6_hello++;	/* increment statistacs */
    if (v->uv_flags & (VIFF_DOWN | VIFF_DISABLED | MIFF_REGISTER))
	return (FALSE);		/* Shoudn't come on this interface */

    data_ptr = (u_int8 *) (pim_message + sizeof(struct pim));

    /* Get the Holdtime (in seconds) from the message. Return if error. */

    if (parse_pim6_hello(pim_message, datalen, src, &holdtime) == FALSE)
	return (FALSE);
    IF_DEBUG(DEBUG_PIM_HELLO | DEBUG_PIM_TIMER)
	log(LOG_DEBUG, 0, "PIM HELLO holdtime from %s is %u",
	    inet6_fmt(&src->sin6_addr), holdtime);

    for (prev_nbr = (pim_nbr_entry_t *) NULL, nbr = v->uv_pim_neighbors;
	 nbr != (pim_nbr_entry_t *) NULL;
	 prev_nbr = nbr, nbr = nbr->next)
    {
	/*
	 * The PIM neighbors are sorted in decreasing order of the network
	 * addresses (note that to be able to compare them correctly we must
	 * translate the addresses in host order.
	 */

	if (inet6_lessthan(src, &nbr->address))
	    continue;
	if (inet6_equal(src, &nbr->address))
	{
	    /* We already have an entry for this host */

	    if (0 == holdtime)
	    {
		/*
		 * Looks like we have a nice neighbor who is going down and
		 * wants to inform us by sending "holdtime=0". Thanks buddy
		 * and see you again!
		 */

		log(LOG_INFO, 0, "PIM HELLO received: neighbor %s going down",
		    inet6_fmt(&src->sin6_addr));
		delete_pim6_nbr(nbr);
		return (TRUE);
	    }
	    SET_TIMER(nbr->timer, holdtime);
	    return (TRUE);
	}
	else
	    /*
	     * No entry for this neighbor. Exit the loop and create an entry
	     * for it.
	     */
	    break;
    }

    /*
     * This is a new neighbor. Create a new entry for it. It must be added
     * right after `prev_nbr`
     */

    new_nbr = (pim_nbr_entry_t *) malloc(sizeof(pim_nbr_entry_t));
    new_nbr->address 		= *src;
    new_nbr->vifi 		= mifi;
    SET_TIMER(new_nbr->timer, holdtime);
    new_nbr->build_jp_message 	= (build_jp_message_t *) NULL;
    new_nbr->next 		= nbr;
    new_nbr->prev 		= prev_nbr;

    if (prev_nbr != (pim_nbr_entry_t *) NULL)
	prev_nbr->next = new_nbr;
    else
	v->uv_pim_neighbors = new_nbr;
    if (new_nbr->next != (pim_nbr_entry_t *) NULL)
	new_nbr->next->prev = new_nbr;

    v->uv_flags &= ~VIFF_NONBRS;
    v->uv_flags |= VIFF_PIM_NBR;

    /* Since a new neighbour has come up, let it know your existence */
    /*
     * XXX: TODO: not in the spec, but probably should send the message after
     * a short random period?
     */

    send_pim6_hello(v, pim_hello_holdtime);

    if (v->uv_flags & VIFF_DR)
    {
	/*
	 * If I am the current DR on that interface, so send an RP-Set
	 * message to the new neighbor.
	 */

	if ((bsr_length = create_pim6_bootstrap_message(pim6_send_buf)))
    		send_pim6(pim6_send_buf, &v->uv_linklocal->pa_addr , src , PIM_BOOTSTRAP,
	     		  bsr_length);


	/* The router with highest network address is the elected DR */
	if (inet6_lessthan(&v->uv_linklocal->pa_addr,&v->uv_pim_neighbors->address))
	{
	    /*
	     * I was the DR, but not anymore. Remove all register_vif from
	     * oif list for all directly connected sources (for vifi).
	     */
	    /* TODO: XXX: first entry is not used! */
	    for (srcentry_ptr = srclist->next;
		 srcentry_ptr != (srcentry_t *) NULL;
		 srcentry_ptr = srcentry_ptr->next)
	    {
		/* If not directly connected source for vifi */

		if ((srcentry_ptr->incoming != mifi)
		    || (srcentry_ptr->upstream != (pim_nbr_entry_t *) NULL))
		    continue;
		for (mrtentry_ptr = srcentry_ptr->mrtlink;
		     mrtentry_ptr != (mrtentry_t *) NULL;
		     mrtentry_ptr = mrtentry_ptr->srcnext)
		{
		    if (!(mrtentry_ptr->flags & MRTF_SG))
			continue;	/* This is not (S,G) entry */
		    /* Remove the register oif */
		    IF_CLR(reg_vif_num, &mrtentry_ptr->joined_oifs);
		    change_interfaces(mrtentry_ptr,
				      mrtentry_ptr->incoming,
				      &mrtentry_ptr->joined_oifs,
				      &mrtentry_ptr->pruned_oifs,
				      &mrtentry_ptr->leaves,
				      &mrtentry_ptr->asserted_oifs, 0);
		}
	    }
	    v->uv_flags &= ~VIFF_DR;
	    v->uv_flags &= ~VIFF_QUERIER;

	}
    }

    /*
     * TODO: XXX: does a new neighbor change any routing entries info? Need
     * to trigger joins?
     */

    IF_DEBUG(DEBUG_PIM_HELLO)
	log(LOG_DEBUG,0,"I'have got a new neighbor %s on vif %s",inet6_fmt(&src->sin6_addr),v->uv_name);
    return (TRUE);
}


void
delete_pim6_nbr(nbr_delete)
    pim_nbr_entry_t *nbr_delete;
{
    srcentry_t     *srcentry_ptr;
    srcentry_t     *srcentry_ptr_next;
    mrtentry_t     *mrtentry_ptr;
    mrtentry_t     *mrtentry_srcs;
    grpentry_t     *grpentry_ptr;
    pim_nbr_entry_t *new_nbr;
    cand_rp_t      *cand_rp_ptr;
    rp_grp_entry_t *rp_grp_entry_ptr;
    rpentry_t      *rpentry_ptr;
    struct uvif    *v;

    v = &uvifs[nbr_delete->vifi];

    /* Delete the entry from the pim_nbrs chain */

    if (nbr_delete->prev != (pim_nbr_entry_t *) NULL)
	nbr_delete->prev->next = nbr_delete->next;
    else
	v->uv_pim_neighbors = nbr_delete->next;
    if (nbr_delete->next != (pim_nbr_entry_t *) NULL)
	nbr_delete->next->prev = nbr_delete->prev;

    return_jp6_working_buff(nbr_delete);

    if (v->uv_pim_neighbors == (pim_nbr_entry_t *) NULL)
    {
	/* This was our last neighbor. */
	v->uv_flags &= ~VIFF_PIM_NBR;
	v->uv_flags |= (VIFF_NONBRS | VIFF_DR);
    }
    else
    {
	if  (inet6_greaterthan(&v->uv_linklocal->pa_addr,
	    &v->uv_pim_neighbors->address))

	    /*
	     * The first address is the new potential remote DR address, but
	     * the local address is the winner.
	     */

	    v->uv_flags |= VIFF_DR;
   	    v->uv_flags |= VIFF_QUERIER;
    }

    /* Update the source entries */
    for (srcentry_ptr = srclist; srcentry_ptr != (srcentry_t *) NULL;
	 srcentry_ptr = srcentry_ptr_next)
    {
	srcentry_ptr_next = srcentry_ptr->next;

	if (srcentry_ptr->upstream != nbr_delete)
	    continue;

	/* Reset the next hop (PIM) router */

	if (set_incoming(srcentry_ptr, PIM_IIF_SOURCE) == FALSE)
	{
	    /*
	     * Coudn't reset it. Sorry, the hext hop router toward that
	     * source is probably not a PIM router, or cannot find route at
	     * all, hence I cannot handle this source and have to delete it.
	     */
	    delete_srcentry(srcentry_ptr);
	}
	else
	    if (srcentry_ptr->upstream != (pim_nbr_entry_t *) NULL)
	    {
		/* Ignore the local or directly connected sources */
		/*
		 * Browse all MRT entries for this source and reset the
		 * upstream router. Note that the upstream router is not
		 * always toward the source: it could be toward the RP for
		 * example.
		 */
		new_nbr = srcentry_ptr->upstream;
		for (mrtentry_ptr = srcentry_ptr->mrtlink;
		     mrtentry_ptr != (mrtentry_t *) NULL;
		     mrtentry_ptr = mrtentry_ptr->srcnext)
		{
		    if (!(mrtentry_ptr->flags & MRTF_RP))
		    {
			mrtentry_ptr->upstream = srcentry_ptr->upstream;
			mrtentry_ptr->metric = srcentry_ptr->metric;
			mrtentry_ptr->preference = srcentry_ptr->preference;
			change_interfaces(mrtentry_ptr, srcentry_ptr->incoming,
					  &mrtentry_ptr->joined_oifs,
					  &mrtentry_ptr->pruned_oifs,
					  &mrtentry_ptr->leaves,
					  &mrtentry_ptr->asserted_oifs, 0);
		    }
		}
	    }
    }

    /* Update the RP entries */
    for (cand_rp_ptr = cand_rp_list; cand_rp_ptr != (cand_rp_t *) NULL;
	 cand_rp_ptr = cand_rp_ptr->next)
    {
	if (cand_rp_ptr->rpentry->upstream != nbr_delete)
	    continue;
	rpentry_ptr = cand_rp_ptr->rpentry;
	/* Reset the RP entry iif */
	/* TODO: check if error setting the iif! */
	if (local_address(&rpentry_ptr->address) == NO_VIF)
	{
		   set_incoming(rpentry_ptr, PIM_IIF_RP);
	}
	else
	{
	    rpentry_ptr->incoming = reg_vif_num;
	    rpentry_ptr->upstream = (pim_nbr_entry_t *) NULL;
	}
	mrtentry_ptr = rpentry_ptr->mrtlink;
	if (mrtentry_ptr != (mrtentry_t *) NULL)
	{
	    mrtentry_ptr->upstream = rpentry_ptr->upstream;
	    mrtentry_ptr->metric = rpentry_ptr->metric;
	    mrtentry_ptr->preference = rpentry_ptr->preference;
	    change_interfaces(mrtentry_ptr,
			      rpentry_ptr->incoming,
			      &mrtentry_ptr->joined_oifs,
			      &mrtentry_ptr->pruned_oifs,
			      &mrtentry_ptr->leaves,
			      &mrtentry_ptr->asserted_oifs, 0);
	}
	/* Update the group entries for this RP */
	for (rp_grp_entry_ptr = cand_rp_ptr->rp_grp_next;
	     rp_grp_entry_ptr != (rp_grp_entry_t *) NULL;
	     rp_grp_entry_ptr = rp_grp_entry_ptr->rp_grp_next)
	{
	    for (grpentry_ptr = rp_grp_entry_ptr->grplink;
		 grpentry_ptr != (grpentry_t *) NULL;
		 grpentry_ptr = grpentry_ptr->rpnext)
	    {
		mrtentry_ptr = grpentry_ptr->grp_route;
		if (mrtentry_ptr != (mrtentry_t *) NULL)
		{
		    mrtentry_ptr->upstream = rpentry_ptr->upstream;
		    mrtentry_ptr->metric = rpentry_ptr->metric;
		    mrtentry_ptr->preference = rpentry_ptr->preference;
		    change_interfaces(mrtentry_ptr,
				      rpentry_ptr->incoming,
				      &mrtentry_ptr->joined_oifs,
				      &mrtentry_ptr->pruned_oifs,
				      &mrtentry_ptr->leaves,
				      &mrtentry_ptr->asserted_oifs, 0);
		}
		/* Update only the (S,G)RPbit entries for this group */
		for (mrtentry_srcs = grpentry_ptr->mrtlink;
		     mrtentry_srcs != (mrtentry_t *) NULL;
		     mrtentry_srcs = mrtentry_srcs->grpnext)
		{
		    if (mrtentry_srcs->flags & MRTF_RP)
		    {
			mrtentry_ptr->upstream = rpentry_ptr->upstream;
			mrtentry_ptr->metric = rpentry_ptr->metric;
			mrtentry_ptr->preference = rpentry_ptr->preference;
			change_interfaces(mrtentry_srcs,
					  rpentry_ptr->incoming,
					  &mrtentry_srcs->joined_oifs,
					  &mrtentry_srcs->pruned_oifs,
					  &mrtentry_srcs->leaves,
					  &mrtentry_srcs->asserted_oifs, 0);
		    }
		}
	    }
	}
    }

    free((char *) nbr_delete);
}


/* TODO: simplify it! */
static int
parse_pim6_hello(pim_message, datalen, src, holdtime)
    char           	*pim_message;
    int             	datalen;
    struct sockaddr_in6 *src;
    u_int16        	*holdtime;
{
    u_int8         *pim_hello_message;
    u_int8         *data_ptr;
    u_int16         option_type;
    u_int16         option_length;
    int             holdtime_received_ok = FALSE;
    int             option_total_length;

    pim_hello_message = (u_int8 *) (pim_message + sizeof(struct pim));
    datalen -= sizeof(struct pim);
    for (; datalen >= sizeof(pim_hello_t);)
    {
	/* Ignore any data if shorter than (pim_hello header) */
	data_ptr = pim_hello_message;
	GET_HOSTSHORT(option_type, data_ptr);
	GET_HOSTSHORT(option_length, data_ptr);
	switch (option_type)
	{
	case PIM_MESSAGE_HELLO_HOLDTIME:
	    if (PIM_MESSAGE_HELLO_HOLDTIME_LENGTH != option_length)
	    {
		IF_DEBUG(DEBUG_PIM_HELLO)
		    log(LOG_DEBUG, 0,
		    "PIM HELLO Holdtime from %s: invalid OptionLength = %u",
			inet6_fmt(&src->sin6_addr), option_length);
		return (FALSE);
	    }
	    GET_HOSTSHORT(*holdtime, data_ptr);
	    holdtime_received_ok = TRUE;
	    break;
	default:
	    /* Ignore any unknown options */
	    break;
	}

	/* Move to the next option */
	/*
	 * XXX: TODO: If we are padding to the end of the 32 bit boundary,
	 * use the first method to move to the next option, otherwise simply
	 * (sizeof(pim_hello_t) + option_length).
	 */

#ifdef BOUNDARY_32_BIT
	option_total_length = (sizeof(pim_hello_t) + (option_length & ~0x3) +
			       ((option_length & 0x3) ? 4 : 0));
#else
	option_total_length = (sizeof(pim_hello_t) + option_length);
#endif				/* BOUNDARY_32_BIT */
	datalen -= option_total_length;
	pim_hello_message += option_total_length;
    }
    return (holdtime_received_ok);
}


int
send_pim6_hello(v, holdtime)
    struct uvif    *v;
    u_int16         holdtime;
{
    char           *buf;
    u_int8         *data_ptr;

    int             datalen;

    buf = pim6_send_buf + sizeof(struct pim);
    data_ptr = (u_int8 *) buf;
    PUT_HOSTSHORT(PIM_MESSAGE_HELLO_HOLDTIME, data_ptr);
    PUT_HOSTSHORT(PIM_MESSAGE_HELLO_HOLDTIME_LENGTH, data_ptr);
    PUT_HOSTSHORT(holdtime, data_ptr);

    datalen = data_ptr - (u_int8 *) buf;

    send_pim6(pim6_send_buf, &v->uv_linklocal->pa_addr,
	      &allpim6routers_group, PIM_HELLO, datalen);
    SET_TIMER(v->uv_pim_hello_timer, pim_hello_period);

    v->uv_out_pim6_hello++;
    return (TRUE);
}

/************************************************************************
 *                        PIM_REGISTER
 ************************************************************************/
/*
 * TODO: XXX: IF THE BORDER BIT IS SET, THEN FORWARD THE WHOLE PACKET FROM
 * USER SPACE AND AT THE SAME TIME IGNORE ANY CACHE_MISS SIGNALS FROM THE
 * KERNEL.
 */

int
receive_pim6_register(reg_src, reg_dst, pim_message, datalen)
    struct sockaddr_in6     *reg_src,
                    		*reg_dst;
    char           			*pim_message;
    int             		datalen;
{
    struct sockaddr_in6		inner_src,
                    		inner_grp;
    pim_register_t		*register_p;
    struct ip6_hdr    		*ip;
    u_int32         		borderBit,
                    		nullRegisterBit;
    mrtentry_t 			*mrtentry_ptr;
    mrtentry_t 			*mrtentry_ptr2;
    if_set			oifs;

    pim6dstat.in_pim6_register++;

    register_p = (pim_register_t *) (pim_message + sizeof(struct pim));

    borderBit = ntohl(register_p->reg_flags) & PIM_MESSAGE_REGISTER_BORDER_BIT;
    nullRegisterBit =
	ntohl(register_p->reg_flags) & PIM_MESSAGE_REGISTER_NULL_REGISTER_BIT;

    /* initialize the pointer to the encapsulated packet */
    ip = (struct ip6_hdr *) (register_p + 1);

    /*
     * We are keeping all addresses in network order,
     * so no need for byte order translation.
     */
    inner_src.sin6_addr = ip->ip6_src;
    inner_grp.sin6_addr = ip->ip6_dst;

    /* scope validation of the inner source and destination addresses */
    if (IN6_IS_ADDR_LINKLOCAL(&ip->ip6_src)) {
	    log(LOG_WARNING, 0,
		"receive_pim6_register: inner source(%s) has invalid scope",
		inet6_fmt(&ip->ip6_src));
    }
#ifdef notyet
    if (IN6_IS_ADDR_SITELOCAL)
	    inner_src.sin6_scope_id = addr2scopeid(&ip->ip6_src, &ip->ip6_dst,
						   reg_src, reg_dst);
    else
#endif
	    inner_src.sin6_scope_id = 0;

    if (IN6_IS_ADDR_MC_NODELOCAL(&ip->ip6_dst) ||
	IN6_IS_ADDR_MC_LINKLOCAL(&ip->ip6_dst)) {
	    log(LOG_WARNING, 0,
		"receive_pim6_register: inner group(%s) has invalid scope",
		inet6_fmt(&ip->ip6_dst));
	    return(FALSE);	/* XXX: can we discard it? */
    }
#ifdef notyet
    if (IN6_IS_ADDR_MC_SITELOCAL(&ip->ip6_dst))
	    inner_grp.sin6_scope_id = addr2scopeid(&ip->ip6_src, &ip->ip6_dst,
						   reg_src, reg_dst);
    else
	    inner_grp.sin6_scope_id = 0;
#endif
    inner_grp.sin6_scope_id = 0;

    mrtentry_ptr = find_route(&inner_src, &inner_grp,
			      MRTF_SG | MRTF_WC | MRTF_PMBR, DONT_CREATE);

    if (mrtentry_ptr == (mrtentry_t *) NULL)
    {

	/* No routing entry. Send REGISTER_STOP and return. */

	IF_DEBUG(DEBUG_PIM_REGISTER)
	    log(LOG_DEBUG, 0,
		"No routing entry for source %s and/or group %s",
		inet6_fmt(&inner_src.sin6_addr), inet6_fmt(&inner_grp.sin6_addr));

	/* TODO: XXX: shouldn't be inner_src=IN6ADDR_ANY? Not in the spec. */

	send_pim6_register_stop(reg_dst, reg_src, &inner_grp, &inner_src);
	return (TRUE);
    }

    /* XXX: not in the spec: check if I am the RP for that group */
	if (!inet6_equal(&my_cand_rp_address, reg_dst)
	|| (check_mrtentry_rp(mrtentry_ptr, &my_cand_rp_address) == FALSE))
    {
	send_pim6_register_stop(reg_dst, reg_src, &inner_grp, &inner_src);
	return (TRUE);
    }

    if (mrtentry_ptr->flags & MRTF_SG)
    {

	/* (S,G) found */
	/* TODO: check the timer again */

	SET_TIMER(mrtentry_ptr->timer, pim_data_timeout);	/* restart timer */
	if (!(mrtentry_ptr->flags & MRTF_SPT))
	{
		/* The SPT bit is not set */

	    if (!nullRegisterBit)
	    {
		calc_oifs(mrtentry_ptr, &oifs);
		if (IF_ISEMPTY(&oifs)
		    && (mrtentry_ptr->incoming == reg_vif_num))
		{
		    send_pim6_register_stop(reg_dst, reg_src, &inner_grp,
					   				&inner_src);
		    return (TRUE);
		}

		/*
		 * TODO: XXX: BUG!!! The data will be forwarded by the kernel
		 * MFC!!! Need to set a special flag for this routing entry
		 * so after a cache miss occur, the multicast packet will be
		 * forwarded from user space and won't install entry in the
		 * kernel MFC. The problem is that the kernel MFC doesn't
		 * know the PMBR address and simply sets the multicast
		 * forwarding cache to accept/forward all data coming from
		 * the register_vif.
		 */

		if (borderBit)
		{
		    if (!inet6_equal(&mrtentry_ptr->pmbr_addr,reg_src))
		    {
			send_pim6_register_stop(reg_dst, reg_src,
					       			&inner_grp, &inner_src);
			return (TRUE);

		    }
		}
		return (TRUE);
	    }
	    /* TODO: XXX: if NULL_REGISTER and has (S,G) with SPT=0, then..? */
	    return (TRUE);
	}
	else
	{
	    /* The SPT bit is set */
	    send_pim6_register_stop(reg_dst, reg_src, &inner_grp, &inner_src);
	    return (TRUE);
	}
    }
    if (mrtentry_ptr->flags & (MRTF_WC | MRTF_PMBR))
    {
	if (borderBit)
	{
	    /*
	     * Create (S,G) state. The oifs will be the copied from the
	     * existing (*,G) or (*,*,RP) entry.
	     */

	    mrtentry_ptr2 = find_route(&inner_src, &inner_grp, MRTF_SG,
				       CREATE);
	    if (mrtentry_ptr2 != (mrtentry_t *) NULL)
	    {
		mrtentry_ptr2->pmbr_addr = *reg_src;

		/* Clear the SPT flag */

		mrtentry_ptr2->flags &= ~(MRTF_SPT | MRTF_NEW);
		SET_TIMER(mrtentry_ptr2->timer, pim_data_timeout);

		/* TODO: explicitly call the Join/Prune send function? */

		FIRE_TIMER(mrtentry_ptr2->jp_timer);	/* Send the Join
							 * immediately */
		/*
		 * TODO: explicitly call this function?
		 * send_pim6_join_prune(mrtentry_ptr2->upstream->vifi,
		 * mrtentry_ptr2->upstream, pim_join_prune_holdtime);
		 */
	    }
	}
    }

    if (mrtentry_ptr->flags & MRTF_WC)
    {
	/* (*,G) entry */

	calc_oifs(mrtentry_ptr, &oifs);
	if (IF_ISEMPTY(&oifs))
	{
	    send_pim6_register_stop(reg_dst, reg_src, &inner_grp, &sockaddr6_any);
	    return (FALSE);
	}

	/* XXX: TODO: check with the spec again */

	else
	{
	    if (!nullRegisterBit)
	    {
		/* Install cache entry in the kernel */
		/*
		 * TODO: XXX: probably redundant here, because the
		 * decapsulated mcast packet in the kernel will result in
		 * CACHE_MISS
		 */

		struct sockaddr_in6    *mfc_source = &inner_src;


#ifdef KERNEL_MFC_WC_G
		if (!(mrtentry_ptr->flags & MRTF_MFC_CLONE_SG))
		    mfc_source = NULL;
#endif				/* KERNEL_MFC_WC_G */

		add_kernel_cache(mrtentry_ptr, mfc_source, &inner_grp, 0);
		k_chg_mfc(mld6_socket, mfc_source, &inner_grp,
			  mrtentry_ptr->incoming, &mrtentry_ptr->oifs,
			  &mrtentry_ptr->group->rpaddr);
		return (TRUE);
	    }
	}
	return (TRUE);
    }

    if (mrtentry_ptr->flags & MRTF_PMBR)
    {
	/* (*,*,RP) entry */
	if (!nullRegisterBit)
	{
	    struct sockaddr_in6		*mfc_source = &inner_src;

	    /*
	     * XXX: have to create either (S,G) or (*,G). The choice below is
	     * (*,G)
	     */

	    mrtentry_ptr2 = find_route(NULL, &inner_grp, MRTF_WC,
				       CREATE);
	    if (mrtentry_ptr2 == (mrtentry_t *) NULL)
		return (FALSE);
	    if (mrtentry_ptr2->flags & MRTF_NEW)
	    {
		/* TODO: something else? Have the feeling sth is missing */

		mrtentry_ptr2->flags &= ~MRTF_NEW;

		/* TODO: XXX: copy the timer from the (*,*,RP) entry? */

		COPY_TIMER(mrtentry_ptr->timer, mrtentry_ptr2->timer);
	    }
	    /* Install cache entry in the kernel */

#ifdef KERNEL_MFC_WC_G

	    if (!(mrtentry_ptr->flags & MRTF_MFC_CLONE_SG))
		mfc_source = NULL;
#endif				/* KERNEL_MFC_WC_G */
	    add_kernel_cache(mrtentry_ptr, mfc_source, &inner_grp, 0);
	    k_chg_mfc(mld6_socket, mfc_source, &inner_grp,
		      mrtentry_ptr->incoming, &mrtentry_ptr->oifs,
		      &mrtentry_ptr2->group->rpaddr);

	    return (TRUE);
	}
    }

    /* Shoudn't happen: invalid routing entry? */
    /* XXX: TODO: shoudn't be inner_src=IN6ADDR_ANY? Not in the spec. */

    send_pim6_register_stop(reg_dst, reg_src, &inner_grp, &inner_src);
    return (TRUE);
}


int
send_pim6_register(pkt)
    char *pkt;
{
    register struct ip6_hdr *ip6;
    static struct sockaddr_in6		source= {sizeof(source) , AF_INET6 };
    static struct sockaddr_in6 		group= {sizeof(group) , AF_INET6 };
    mifi_t          		mifi;
    rpentry_t      		*rpentry_ptr;
    mrtentry_t     		*mrtentry_ptr;
    mrtentry_t     		*mrtentry_ptr2;

    struct sockaddr_in6		*reg_src,
                    		*reg_dst;
    int             		pktlen = 0;
    char           		*buf;

    ip6=(struct ip6_hdr *)pkt;

    group.sin6_addr = ip6->ip6_dst;
    source.sin6_addr = ip6->ip6_src;

    if ((mifi = find_vif_direct_local(&source)) == NO_VIF)
	return (FALSE);

    if (!(uvifs[mifi].uv_flags & VIFF_DR))
	return (FALSE);		/* I am not the DR for that subnet */



    rpentry_ptr = rp_match(&group);
    if (rpentry_ptr == (rpentry_t *) NULL)
	return (FALSE);		/* No RP for this group */
    if (local_address(&rpentry_ptr->address) != NO_VIF)
	/* TODO: XXX: not sure it is working! */
	return (FALSE);		/* I am the RP for this group */

    mrtentry_ptr = find_route(&source, &group, MRTF_SG, CREATE);
    if (mrtentry_ptr == (mrtentry_t *) NULL)
	return (FALSE);		/* Cannot create (S,G) state */

    if (mrtentry_ptr->flags & MRTF_NEW)
    {
	/* A new entry */
	mrtentry_ptr->flags &= ~MRTF_NEW;
	RESET_TIMER(mrtentry_ptr->rs_timer);	/* Reset the
						 * Register-Suppression timer */
	if ((mrtentry_ptr2 = mrtentry_ptr->group->grp_route) ==
	    (mrtentry_t *) NULL)
	    mrtentry_ptr2 =
		mrtentry_ptr->group->active_rp_grp->rp->rpentry->mrtlink;
	if (mrtentry_ptr2 != (mrtentry_t *) NULL)
	{
	    FIRE_TIMER(mrtentry_ptr2->jp_timer);	/* Timeout the
							 * Join/Prune timer */
	    /*
	     * TODO: explicitly call this function?
	     * send_pim6_join_prune(mrtentry_ptr2->upstream->vifi,
	     * mrtentry_ptr2->upstream, pim_join_prune_holdtime);
	     */
	}
    }
    /* Restart the (S,G) Entry-timer */

    SET_TIMER(mrtentry_ptr->timer, pim_data_timeout);

    IF_TIMER_NOT_SET(mrtentry_ptr->rs_timer)
    {
	/*
	 * The Register-Suppression Timer is not running. Encapsulate the
	 * data and send to the RP.
	 */
	buf = pim6_send_buf + sizeof(struct pim);

	bzero(buf, sizeof(pim_register_t));	/* No flags set */
	buf += sizeof(pim_register_t);

	/* Copy the data packet at the back of the register packet */
	/* TODO: check pktlen. ntohs? */

	pktlen = ntohs(ip6->ip6_plen);
	pktlen +=sizeof(struct ip6_hdr);			/* XXX */

	bcopy((char *) ip6, buf, pktlen);
	pktlen += sizeof(pim_register_t);
	reg_src = max_global_address();
	reg_dst = &mrtentry_ptr->group->rpaddr;

    	send_pim6(pim6_send_buf, reg_src , reg_dst , PIM_REGISTER,
	     	  pktlen);

	pim6dstat.out_pim6_register++;

	return (TRUE);
    }
    return (TRUE);
}

int
send_pim6_null_register(mrtentry_ptr)
    mrtentry_t     *mrtentry_ptr;
{
	struct 				ip6_hdr *ip;
    pim_register_t 		*pim_register;
    int             		pktlen = 0;
    mifi_t          		mifi;
    struct sockaddr_in6  	*reg_source,
                    		*dest;

    /* No directly connected source; no local address */

    if ((mifi = find_vif_direct_local(&mrtentry_ptr->source->address)) == NO_VIF)
	return (FALSE);

    pim_register = (pim_register_t *) (pim6_send_buf  + sizeof(struct pim));
    bzero((char *) pim_register, sizeof(pim_register_t));
    pim_register->reg_flags = htonl(pim_register->reg_flags
				  | PIM_MESSAGE_REGISTER_NULL_REGISTER_BIT);

    /* include the dummy ip header */
    ip = (struct ip6_hdr *) (pim_register +1);
    ip->ip6_plen= 0;
    ip->ip6_flow=0;
    ip->ip6_vfc = 0x60;
    ip->ip6_hlim = MINHLIM;
    ip->ip6_nxt = IPPROTO_NONE;
    ip->ip6_src = mrtentry_ptr->source->address.sin6_addr;
    ip->ip6_dst = mrtentry_ptr->group->group.sin6_addr;

    pktlen = sizeof(pim_register_t) + sizeof(struct ip6_hdr);

    dest = &mrtentry_ptr->group->rpaddr;
    reg_source = max_global_address();

    send_pim6(pim6_send_buf, reg_source , dest, PIM_REGISTER,
	      pktlen);
    pim6dstat.out_pim6_register++; /* should be counted separately? */

    return (TRUE);
}


/************************************************************************
 *                        PIM_REGISTER_STOP
 ************************************************************************/
int
receive_pim6_register_stop(reg_src, reg_dst, pim_message, datalen)
    struct sockaddr_in6 	*reg_src,
                    		*reg_dst;
    char           		*pim_message;
    register int    		datalen;
{
    pim_register_stop_t 	*pim_regstop_p;
    pim6_encod_grp_addr_t 	encod_grp;
    pim6_encod_uni_addr_t 	encod_unisrc;
    struct sockaddr_in6		source,
							group;
    u_int8         		*data_ptr;
    mrtentry_t     		*mrtentry_ptr;
    if_set     			pruned_oifs;
    mifi_t			mifi;
    struct uvif 		*v;

    pim6dstat.in_pim6_register_stop++;

    pim_regstop_p = (pim_register_stop_t *) (pim_message +
					     sizeof(struct pim));
    data_ptr = (u_int8 *) & pim_regstop_p->encod_grp;
    GET_EGADDR6(&encod_grp, data_ptr);
    GET_EUADDR6(&encod_unisrc, data_ptr);

    group.sin6_addr = encod_grp.mcast_addr;

    /* scope validation of the inner source and destination addresses */

#ifdef notyet
    if (IN6_IS_ADDR_MC_SITELOCAL(&ip->ip6_dst))
	    group.sin6_scope_id = addr2scopeid(&ip->ip6_src, &ip->ip6_dst,
						   reg_src, reg_dst);
    else
#endif

    group.sin6_scope_id = 0;
    source.sin6_addr = encod_unisrc.unicast_addr;

    /* the source address must be global...but is it always true? */

#ifdef notyet
    if (IN6_IS_ADDR_SITELOCAL)
	    source.sin6_scope_id = addr2scopeid(&ip->ip6_src, &ip->ip6_dst,
						   reg_src, reg_dst);
    else
#endif

    source.sin6_scope_id = 0;

    if((mifi= find_vif_direct_local(&source))==NO_VIF)
    {
	    IF_DEBUG(DEBUG_PIM_REGISTER)
		    {
			    log(LOG_WARNING,0,
				"Received PIM_REGISTER_STOP from RP %s for a non "
				"direct-connect source %s",
				inet6_fmt(&reg_src->sin6_addr),
				inet6_fmt(&encod_unisrc.unicast_addr));
		    }
	    return FALSE;
    }

    v=&uvifs[mifi];


    group.sin6_scope_id = inet6_uvif2scopeid(&group, v);
    source.sin6_scope_id = inet6_uvif2scopeid(&source,
					      v);


    IF_DEBUG(DEBUG_PIM_REGISTER)
	{
		log(LOG_DEBUG, 0,
		    "Received PIM_REGISTER_STOP from RP %s to %s "
		    "source : %s group : %s",
		    inet6_fmt(&reg_src->sin6_addr),
		    inet6_fmt(&reg_dst->sin6_addr),
		    inet6_fmt(&encod_unisrc.unicast_addr),
		    inet6_fmt(&encod_grp.mcast_addr));
	}

    /* TODO: apply the group mask and do register_stop for all grp addresses */
    /* TODO: check for SourceAddress == 0 */


    mrtentry_ptr = find_route(&source, &group,
			      MRTF_SG, DONT_CREATE);
    if (mrtentry_ptr == (mrtentry_t *) NULL)
    {
	return (FALSE);
    }

    /*
     * XXX: not in the spec: check if the PIM_REGISTER_STOP originator is
     * really the RP
     */


    if (check_mrtentry_rp(mrtentry_ptr, reg_src) == FALSE)
    {
	return (FALSE);
    }

    /* restart the Register-Suppression timer */

    SET_TIMER(mrtentry_ptr->rs_timer, (0.5 * pim_register_suppression_timeout)
	      + (RANDOM() % (pim_register_suppression_timeout + 1)));
    /* Prune the register_vif from the outgoing list */

    IF_COPY(&mrtentry_ptr->pruned_oifs, &pruned_oifs);
    IF_SET(reg_vif_num, &pruned_oifs);
    change_interfaces(mrtentry_ptr, mrtentry_ptr->incoming,
		      &mrtentry_ptr->joined_oifs, &pruned_oifs,
		      &mrtentry_ptr->leaves,
		      &mrtentry_ptr->asserted_oifs, 0);
    return (TRUE);
}


/* TODO: optional rate limiting is not implemented yet */
/* Unicasts a REGISTER_STOP message to the DR */

static int
send_pim6_register_stop(reg_src, reg_dst, inner_grp, inner_src)
    struct sockaddr_in6		*reg_src,
                    		*reg_dst,
                    		*inner_grp,
                    		*inner_src;
{
    char           *buf;
    u_int8         *data_ptr;

    buf = pim6_send_buf +  sizeof(struct pim);
    data_ptr = (u_int8 *) buf;
    PUT_EGADDR6(inner_grp->sin6_addr, SINGLE_GRP_MSK6LEN, 0, data_ptr);
    PUT_EUADDR6(inner_src->sin6_addr, data_ptr);

    send_pim6(pim6_send_buf, reg_src , reg_dst , PIM_REGISTER_STOP,
	      data_ptr-(u_int8 *) buf);
    pim6dstat.out_pim6_register_stop++;

    return (TRUE);
}

/************************************************************************
 *                        PIM_JOIN_PRUNE
 ************************************************************************/
int
join_or_prune(mrtentry_ptr, upstream_router)
    mrtentry_t     *mrtentry_ptr;
    pim_nbr_entry_t *upstream_router;
{
    if_set     		entry_oifs;
    mrtentry_t     	*mrtentry_grp;

    if ((mrtentry_ptr == (mrtentry_t *) NULL))
    {
	IF_DEBUG(DEBUG_PIM_JOIN_PRUNE)
	    log(LOG_DEBUG,0,"Join_or_prune : mrtentry_ptr is null");
	return (PIM_ACTION_NOTHING);
    }
    if( upstream_router == (pim_nbr_entry_t *) NULL)
    {
	IF_DEBUG(DEBUG_PIM_JOIN_PRUNE)
	    log(LOG_DEBUG,0,"Join_or_prune : upstream_router is null");
	return (PIM_ACTION_NOTHING);
    }

    calc_oifs(mrtentry_ptr, &entry_oifs);
    if (mrtentry_ptr->flags & (MRTF_PMBR | MRTF_WC))
    {
	/* (*,*,RP) or (*,G) entry */
	/* The (*,*,RP) or (*,G) J/P messages are sent only toward the RP */

	if (upstream_router != mrtentry_ptr->upstream)
	    return (PIM_ACTION_NOTHING);

	/* TODO: XXX: Can we have (*,*,RP) prune? */

	if (IF_ISEMPTY(&entry_oifs))
	{
	    /* NULL oifs */
	    if (!(uvifs[mrtentry_ptr->incoming].uv_flags & VIFF_DR))
	    {
		/* I am not the DR for that subnet. */
		return (PIM_ACTION_PRUNE);
            }
	    if (IF_ISSET(mrtentry_ptr->incoming, &mrtentry_ptr->leaves))
		/* I am the DR and have local leaves */
		return (PIM_ACTION_JOIN);
	    /* Probably the last local member hast timeout */
	    return (PIM_ACTION_PRUNE);
	}
	return (PIM_ACTION_JOIN);
    }

    if (mrtentry_ptr->flags & MRTF_SG)
    {
	/* (S,G) entry */
	/* TODO: check again */
	if (mrtentry_ptr->upstream == upstream_router)
	{
	    if (!(mrtentry_ptr->flags & MRTF_RP))
	    {
		/* Upstream router toward S */
		if (IF_ISEMPTY(&entry_oifs))
		{
		    if (mrtentry_ptr->group->active_rp_grp != (rp_grp_entry_t *)NULL &&
			inet6_equal(&mrtentry_ptr->group->rpaddr,
				    &my_cand_rp_address))
		    {
			/*
			 * (S,G) at the RP. Don't send Join/Prune (see the
			 * end of Section 3.3.2)
			 */

			return (PIM_ACTION_NOTHING);
		    }
		    return (PIM_ACTION_PRUNE);
		}
		else
		    return (PIM_ACTION_JOIN);
	    }
	    else
	    {
		/* Upstream router toward RP */
		if (IF_ISEMPTY(&entry_oifs))
		    return (PIM_ACTION_PRUNE);
	    }
	}

	/*
	 * Looks like the case when the upstream router toward S is different
	 * from the upstream router toward RP
	 */

	if (mrtentry_ptr->group->active_rp_grp == (rp_grp_entry_t *) NULL)
	    return (PIM_ACTION_NOTHING);
	mrtentry_grp = mrtentry_ptr->group->grp_route;
	if (mrtentry_grp == (mrtentry_t *) NULL)
	    mrtentry_grp =
		mrtentry_ptr->group->active_rp_grp->rp->rpentry->mrtlink;
	if (mrtentry_grp == (mrtentry_t *) NULL)
	    return (PIM_ACTION_NOTHING);
	if (mrtentry_grp->upstream != upstream_router)
	    return (PIM_ACTION_NOTHING);	/* XXX: shoudn't happen */

	if ((!(mrtentry_ptr->flags & MRTF_RP))
	    && (mrtentry_ptr->flags & MRTF_SPT))
	{
	    return (PIM_ACTION_PRUNE);
	}
    }
    return (PIM_ACTION_NOTHING);
}

/* TODO: too long, simplify it! */
#define	PIM6_JOIN_PRUNE_MINLEN (4 + PIM6_ENCODE_UNI_ADDR_LEN + 4)

int
receive_pim6_join_prune(src, dst, pim_message, datalen)
    struct sockaddr_in6		*src,
                    		*dst;
    char           		*pim_message;
    register int    		datalen;
{
    mifi_t          		mifi;
    struct uvif    		*v;
    pim6_encod_uni_addr_t 	uni_target_addr;
    pim6_encod_grp_addr_t 	encod_group;
    pim6_encod_src_addr_t 	encod_src;
    u_int8         		*data_ptr;
    u_int8         		*data_ptr_start;
    u_int8          		num_groups;
    u_int8          		num_groups_tmp;
    int             		star_star_rp_found;
    u_int16         		holdtime;
    u_int16         		num_j_srcs;
    u_int16         		num_j_srcs_tmp;
    u_int16         		num_p_srcs;
    struct sockaddr_in6		source;
    struct sockaddr_in6         group;
    struct sockaddr_in6		target;
    struct in6_addr          	s_mask;
    struct in6_addr         	g_mask;
    u_int8          		s_flags;
    u_int8          		reserved;
    rpentry_t      		*rpentry_ptr;
    mrtentry_t     		*mrtentry_ptr;
    mrtentry_t     		*mrtentry_srcs;
    mrtentry_t     		*mrtentry_rp;
    grpentry_t     		*grpentry_ptr;
    u_int16         		jp_value;
    pim_nbr_entry_t 		*upstream_router;
    int             		my_action;
    int             		ignore_group;
    rp_grp_entry_t 		*rp_grp_entry_ptr;
    u_int8         		*data_ptr_group_j_start;
    u_int8         		*data_ptr_group_p_start;

    if ((mifi = find_vif_direct(src)) == NO_VIF)
    {
	/*
	 * Either a local vif or somehow received PIM_JOIN_PRUNE from
	 * non-directly connected router. Ignore it.
	 */

	if (local_address(src) == NO_VIF)
	    log(LOG_INFO, 0,
		"Ignoring PIM_JOIN_PRUNE from non-neighbor router %s",
		inet6_fmt(&src->sin6_addr));
	return (FALSE);
    }

    v = &uvifs[mifi];
    v->uv_in_pim6_join_prune++;
    if (uvifs[mifi].uv_flags &
	(VIFF_DOWN | VIFF_DISABLED | VIFF_NONBRS | MIFF_REGISTER))
    {
	return (FALSE);		/* Shoudn't come on this interface */
    }

    /* sanity check for the minimum length */
    if (datalen < PIM6_JOIN_PRUNE_MINLEN) {
	    log(LOG_NOTICE, 0,
		"receive_pim6_join_prune: Join/Prune message size(%u) is"
		" too short from %s on %s",
		datalen, inet6_fmt(&src->sin6_addr), v->uv_name);
	    return(FALSE);
    }
    datalen -= PIM6_JOIN_PRUNE_MINLEN;
    data_ptr = (u_int8 *) (pim_message + sizeof(struct pim));

    /* Get the target address */
    GET_EUADDR6(&uni_target_addr, data_ptr);
    GET_BYTE(reserved, data_ptr);
    GET_BYTE(num_groups, data_ptr);
    if (num_groups == 0)
	return (FALSE);		/* No indication for groups in the message */
    GET_HOSTSHORT(holdtime, data_ptr);
    target.sin6_len = sizeof(target);
    target.sin6_family = AF_INET6;
    target.sin6_addr = uni_target_addr.unicast_addr;
    target.sin6_scope_id = inet6_uvif2scopeid(&target, v);

    /* Sanity check for the message length through all the groups */
    num_groups_tmp = num_groups;
    data_ptr_start = data_ptr;
    while (num_groups_tmp--) {
	int srclen;

	/* group addr + #join + #src */
	if (datalen < PIM6_ENCODE_GRP_ADDR_LEN + sizeof(u_int32_t)) {
	    log(LOG_NOTICE, 0,
		"receive_pim6_join_prune: Join/Prune message from %s on %s is"
		" too short to contain enough data",
		inet6_fmt(&src->sin6_addr), v->uv_name);
	    return(FALSE);
	}
	datalen -= (PIM6_ENCODE_GRP_ADDR_LEN + sizeof(u_int32_t));
	data_ptr += PIM6_ENCODE_GRP_ADDR_LEN;

	/* joined source addresses and pruned source addresses */
	GET_HOSTSHORT(num_j_srcs, data_ptr);
	GET_HOSTSHORT(num_p_srcs, data_ptr);
	srclen = (num_j_srcs + num_p_srcs) * PIM6_ENCODE_SRC_ADDR_LEN;
	if (datalen < srclen) {
	    log(LOG_NOTICE, 0,
		"receive_pim6_join_prune: Join/Prune message from %s on %s is"
		" too short to contain enough data",
		inet6_fmt(&src->sin6_addr), v->uv_name);
	    return(FALSE);
	}
	datalen -= srclen;
	data_ptr += srclen;
    }
    data_ptr = data_ptr_start;
    num_groups_tmp = num_groups;

    if (!inet6_localif_address(&target, v) &&
	!IN6_IS_ADDR_UNSPECIFIED(&uni_target_addr.unicast_addr))
    {

	/* if I am not the targer of the join message */
	/*
	 * Join/Prune suppression code. This either modifies the J/P timers
	 * or triggers an overriding Join.
	 */
	/*
	 * Note that if we have (S,G) prune and (*,G) Join, we must send them
	 * in the same message. We don't bother to modify both timers here.
	 * The Join/Prune sending function will take care of that.
	 */

	upstream_router = find_pim6_nbr(&target);
	if (upstream_router == (pim_nbr_entry_t *) NULL)
	    return (FALSE);	/* I have no such neighbor */

	group.sin6_len = sizeof(group);
	group.sin6_family = AF_INET6;
	source.sin6_len = sizeof(source);
	source.sin6_family = AF_INET6;

	while (num_groups--)
	{
	    GET_EGADDR6(&encod_group, data_ptr);
	    GET_HOSTSHORT(num_j_srcs, data_ptr);
	    GET_HOSTSHORT(num_p_srcs, data_ptr);
	    if (encod_group.masklen > (sizeof(struct in6_addr) << 3))
		continue;
	    MASKLEN_TO_MASK6(encod_group.masklen, g_mask);
	    group.sin6_addr = encod_group.mcast_addr;
	    group.sin6_scope_id = inet6_uvif2scopeid(&group, v);

	    if (!IN6_IS_ADDR_MULTICAST(&group.sin6_addr))
	    {
		data_ptr +=
		    (num_j_srcs + num_p_srcs) * sizeof(pim6_encod_src_addr_t);
		continue;	/* Ignore this group and jump to the next */
	    }

	    if (inet6_equal(&group,&sockaddr6_d) &&
		(encod_src.masklen == STAR_STAR_RP_MSK6LEN))
	    {
		/* (*,*,RP) Join suppression */

		while (num_j_srcs--)
		{
		    GET_ESADDR6(&encod_src, data_ptr);
		    source.sin6_addr = encod_src.src_addr;
		    source.sin6_scope_id = inet6_uvif2scopeid(&source,
                                      v);
			/* sanity checks */
		    if (!inet6_valid_host(&source))
				continue;
		    if (encod_src.masklen >
                    (sizeof(struct in6_addr) << 3))
                    continue;


	   	    s_flags = encod_src.flags;
		    MASKLEN_TO_MASK6(encod_src.masklen, s_mask);
		    if ((s_flags & USADDR_RP_BIT) &&
			(s_flags & USADDR_WC_BIT))
		    {
			/* This is the RP address. */
			rpentry_ptr = rp_find(&source);
			if (rpentry_ptr == (rpentry_t *) NULL)
			    continue;	/* Don't have such RP. Ignore */
			mrtentry_rp = rpentry_ptr->mrtlink;
			my_action = join_or_prune(mrtentry_rp,
						  upstream_router);
			if (my_action != PIM_ACTION_JOIN)
			    continue;

			/* Check the holdtime */
			/* TODO: XXX: TIMER implem. dependency! */

			if (mrtentry_rp->jp_timer > holdtime)
			    continue;
			if ((mrtentry_rp->jp_timer == holdtime)
			    && (inet6_greaterthan(src, &v->uv_linklocal->pa_addr)))
			    continue;

			/*
			 * Set the Join/Prune suppression timer for this
			 * routing entry by increasing the current Join/Prune
			 * timer.
			 */
			jp_value = pim_join_prune_period +
			    0.5 * (RANDOM() % pim_join_prune_period);
			/* TODO: XXX: TIMER implem. dependency! */

			if (mrtentry_rp->jp_timer < jp_value)
			    SET_TIMER(mrtentry_rp->jp_timer, jp_value);
		    }
		}		/* num_j_srcs */

		while (num_p_srcs--)
		{
		    /*
		     * TODO: XXX: Can we have (*,*,RP) prune message? Not in
		     * the spec, but anyway, the code below can handle them:
		     * either suppress the local (*,*,RP) prunes or override
		     * the prunes by sending (*,*,RP) and/or (*,G) and/or
		     * (S,G) Join.
		     */

		    GET_ESADDR6(&encod_src, data_ptr);
		    source.sin6_addr = encod_src.src_addr;
		    source.sin6_scope_id = inet6_uvif2scopeid(&source,
                                      v);

		    if (!inet6_valid_host(&source))
			continue;

                    if (encod_src.masklen >
                    (sizeof(struct in6_addr) << 3))
                    continue;


		    s_flags = encod_src.flags;
		    MASKLEN_TO_MASK6(encod_src.masklen, s_mask);
		    if ((s_flags & USADDR_RP_BIT) &&
			(s_flags & USADDR_WC_BIT))
		    {
			/* This is the RP address. */
			rpentry_ptr = rp_find(&source);
			if (rpentry_ptr == (rpentry_t *) NULL)
			    continue;	/* Don't have such RP. Ignore */
			mrtentry_rp = rpentry_ptr->mrtlink;
			my_action = join_or_prune(mrtentry_rp,
						  upstream_router);
			if (my_action == PIM_ACTION_PRUNE)
			{
			    /* TODO: XXX: TIMER implem. dependency! */
			    if ((mrtentry_rp->jp_timer < holdtime)
				|| ((mrtentry_rp->jp_timer == holdtime)
			    	&& (inet6_greaterthan(src, &v->uv_linklocal->pa_addr))))
			    {
				/* Suppress the Prune */
				jp_value =  pim_join_prune_period+
				    0.5 * (RANDOM() % pim_join_prune_period);
				if (mrtentry_rp->jp_timer < jp_value)
				    SET_TIMER(mrtentry_rp->jp_timer, jp_value);
			    }
			}
			else
			    if (my_action == PIM_ACTION_JOIN)
			    {
				/* Override the Prune by scheduling a Join */
				jp_value = (RANDOM() % 11) / (10 * PIM_RANDOM_DELAY_JOIN_TIMEOUT);
				/* TODO: XXX: TIMER implem. dependency! */
				if (mrtentry_rp->jp_timer > jp_value)
				    SET_TIMER(mrtentry_rp->jp_timer, jp_value);
			    }
			/*
			 * Check all (*,G) and (S,G) matching to this RP. If
			 * my_action == JOIN, then send a Join and override
			 * the (*,*,RP) Prune.
			 */
			for (grpentry_ptr =
			     rpentry_ptr->cand_rp->rp_grp_next->grplink;
			     grpentry_ptr != (grpentry_t *) NULL;
			     grpentry_ptr = grpentry_ptr->rpnext)
			{
			    my_action = join_or_prune(grpentry_ptr->grp_route,
						      upstream_router);
			    if (my_action == PIM_ACTION_JOIN)
			    {

				jp_value = (RANDOM() % 11) / (10 * PIM_RANDOM_DELAY_JOIN_TIMEOUT);
				/* TODO: XXX: TIMER implem. dependency! */
				if (grpentry_ptr->grp_route->jp_timer >
				    jp_value)
				    SET_TIMER(grpentry_ptr->grp_route->jp_timer, jp_value);
			    }
			    for (mrtentry_srcs = grpentry_ptr->mrtlink;
				 mrtentry_srcs != (mrtentry_t *) NULL;
				 mrtentry_srcs = mrtentry_srcs->grpnext)
			    {
				my_action = join_or_prune(mrtentry_srcs,
							  upstream_router);
				if (my_action == PIM_ACTION_JOIN)
				{

				    jp_value = (RANDOM() % 11) / (10 * PIM_RANDOM_DELAY_JOIN_TIMEOUT);
				    /* TODO: XXX: TIMER implem. dependency! */
				    if (mrtentry_srcs->jp_timer > jp_value)
					SET_TIMER(mrtentry_srcs->jp_timer, jp_value);
				}
			    }	/* For all (S,G) */
			}	/* For all (*,G) */
		    }
		}		/* num_p_srcs */
		continue;	/* This was (*,*,RP) suppression */
	    }

	    /* (*,G) or (S,G) suppression */
	    /*
	     * TODO: XXX: currently, accumulated groups (i.e. group_masklen <
	     * group_address_lengt) are not implemented. Just need to create
	     * a loop and apply the procedure below for all groups matching
	     * the prefix.
	     */

	    while (num_j_srcs--)
	    {
		GET_ESADDR6(&encod_src, data_ptr);
		source.sin6_addr  = encod_src.src_addr;
	        source.sin6_scope_id = inet6_uvif2scopeid(&source,v);

		if (!inet6_valid_host(&source))
		    continue;
	        if (encod_src.masklen >
                (sizeof(struct in6_addr) << 3))
                continue;


		s_flags = encod_src.flags;
		MASKLEN_TO_MASK6(encod_src.masklen, s_mask);

		if ((s_flags & USADDR_RP_BIT) && (s_flags & USADDR_WC_BIT))
		{
		    /* (*,G) JOIN_REQUEST (toward the RP) */
		    mrtentry_ptr = find_route(&sockaddr6_any , &group, MRTF_WC,
					      DONT_CREATE);
		    my_action = join_or_prune(mrtentry_ptr, upstream_router);
		    if (my_action != PIM_ACTION_JOIN)
			continue;
		    /* (*,G) Join suppresion */
		    if (!inet6_equal(&source,&mrtentry_ptr->group->active_rp_grp->rp->rpentry->address))
			continue;	/* The RP address doesn't match.
					 * Ignore. */

		    /* Check the holdtime */
		    /* TODO: XXX: TIMER implem. dependency! */
		    if (mrtentry_ptr->jp_timer > holdtime)
			continue;
		    if ((mrtentry_ptr->jp_timer == holdtime)
		    && (inet6_greaterthan(src, &v->uv_linklocal->pa_addr)))
			continue;
		    jp_value = pim_join_prune_period +
			0.5 * (RANDOM() % pim_join_prune_period);
		    if (mrtentry_ptr->jp_timer < jp_value)
			SET_TIMER(mrtentry_ptr->jp_timer, jp_value);
		    continue;
		}		/* End of (*,G) Join suppression */

		/* (S,G) Join suppresion */
		mrtentry_ptr = find_route(&source, &group, MRTF_SG,
					  DONT_CREATE);
		my_action = join_or_prune(mrtentry_ptr, upstream_router);
		if (my_action != PIM_ACTION_JOIN)
		    continue;

		/* Check the holdtime */
		/* TODO: XXX: TIMER implem. dependency! */
		if (mrtentry_ptr->jp_timer > holdtime)
		    continue;
		if ((mrtentry_ptr->jp_timer == holdtime)
		    && (inet6_greaterthan(src, &v->uv_linklocal->pa_addr)))
		    continue;
		jp_value = pim_join_prune_period +
		    0.5 * (RANDOM() % pim_join_prune_period);
		if (mrtentry_ptr->jp_timer < jp_value)
		    SET_TIMER(mrtentry_ptr->jp_timer, jp_value);
		continue;
	    }

	    /* Prunes suppression */
	    while (num_p_srcs--)
	    {
		GET_ESADDR6(&encod_src, data_ptr);
		source.sin6_addr = encod_src.src_addr;
	        source.sin6_scope_id = inet6_uvif2scopeid(&source,
                                 v);
	        if (encod_src.masklen >
                (sizeof(struct in6_addr) << 3))
                continue;


		if (!inet6_valid_host(&source))
		    continue;
		s_flags = encod_src.flags;
		MASKLEN_TO_MASK6(encod_src.masklen, s_mask);
		if ((s_flags & USADDR_RP_BIT) && (s_flags & USADDR_WC_BIT))
		{
		    /* (*,G) prune suppression */
		    rpentry_ptr = rp_match(&source);
		    if ((rpentry_ptr == (rpentry_t *) NULL)
			|| (!inet6_equal(&rpentry_ptr->address , &source)))
			continue;	/* No such RP or it is different.
					 * Ignore */
		    mrtentry_ptr = find_route(&sockaddr6_any, &group, MRTF_WC,
					      DONT_CREATE);
		    my_action = join_or_prune(mrtentry_ptr, upstream_router);
		    if (my_action == PIM_ACTION_PRUNE)
		    {
			/* TODO: XXX: TIMER implem. dependency! */
			if ((mrtentry_ptr->jp_timer < holdtime)
			    || ((mrtentry_ptr->jp_timer == holdtime)
		    		&& (inet6_greaterthan(src, &v->uv_linklocal->pa_addr))))
			{
			    /* Suppress the Prune */
			    jp_value = pim_join_prune_period +
				0.5 * (RANDOM() % pim_join_prune_period);
			    if (mrtentry_ptr->jp_timer < jp_value)
				SET_TIMER(mrtentry_ptr->jp_timer, jp_value);
			}
		    }
		    else
			if (my_action == PIM_ACTION_JOIN)
			{
			    /* Override the Prune by scheduling a Join */
			    jp_value = (RANDOM() % 11) / (10 * PIM_RANDOM_DELAY_JOIN_TIMEOUT);
			    /* TODO: XXX: TIMER implem. dependency! */
			    if (mrtentry_ptr->jp_timer > jp_value)
				SET_TIMER(mrtentry_ptr->jp_timer, jp_value);
			}

		    /*
		     * Check all (S,G) entries for this group. If my_action
		     * == JOIN, then send the Join and override the (*,G)
		     * Prune.
		     */
		    for (mrtentry_srcs = mrtentry_ptr->group->mrtlink;
			 mrtentry_srcs != (mrtentry_t *) NULL;
			 mrtentry_srcs = mrtentry_srcs->grpnext)
		    {
			my_action = join_or_prune(mrtentry_srcs,
						  upstream_router);
			if (my_action == PIM_ACTION_JOIN)
			{
			    jp_value = (RANDOM() % 11) / (10 * PIM_RANDOM_DELAY_JOIN_TIMEOUT);
			    /* TODO: XXX: TIMER implem. dependency! */
			    if (mrtentry_ptr->jp_timer > jp_value)
				SET_TIMER(mrtentry_ptr->jp_timer, jp_value);
			}
		    }		/* For all (S,G) */
		    continue;	/* End of (*,G) prune suppression */
		}

		/* (S,G) prune suppression */
		mrtentry_ptr = find_route(&source, &group, MRTF_SG,
					  DONT_CREATE);
		my_action = join_or_prune(mrtentry_ptr, upstream_router);
		if (my_action == PIM_ACTION_PRUNE)
		{
		    /* Suppress the (S,G) Prune */
		    /* TODO: XXX: TIMER implem. dependency! */
		    if ((mrtentry_ptr->jp_timer < holdtime)
			|| ((mrtentry_ptr->jp_timer == holdtime)
		    	&& (inet6_greaterthan(src, &v->uv_linklocal->pa_addr))))
		    {
			jp_value = pim_join_prune_period +
			    0.5 * (RANDOM() % pim_join_prune_period);
			if (mrtentry_ptr->jp_timer < jp_value)
			    SET_TIMER(mrtentry_ptr->jp_timer, jp_value);
		    }
		}
		else
		    if (my_action == PIM_ACTION_JOIN)
		    {
			/* Override the Prune by scheduling a Join */
			jp_value = (RANDOM() % 11) / (10 * PIM_RANDOM_DELAY_JOIN_TIMEOUT);
			/* TODO: XXX: TIMER implem. dependency! */
			if (mrtentry_ptr->jp_timer > jp_value)
			    SET_TIMER(mrtentry_ptr->jp_timer, jp_value);
		    }
	    }			/* while (num_p_srcs--) */
	}			/* while (num_groups--) */
	return (TRUE);
    }				/* End of Join/Prune suppression code */

    /* I am the target of this join, so process the message */

    /*
     * The spec says that if there is (*,G) Join, it has priority over old
     * existing ~(S,G) prunes in the routing table. However, if the (*,G)
     * Join and the ~(S,G) prune are in the same message, ~(S,G) has the
     * priority. The spec doesn't say it, but I think the same is true for
     * (*,*,RP) and ~(S,G) prunes.
     *
     * The code below do: (1) Check the whole message for (*,*,RP) Joins. (1.1)
     * If found, clean all pruned_oifs for all (*,G) and all (S,G) for each
     * RP in the list, but do not update the kernel cache. Then go back to
     * the beginning of the message and start processing for each group: (2)
     * Check for Prunes. If no prunes, process the Joins. (3) If there are
     * Prunes: (3.1) Scan the Join part for existing (*,G) Join. (3.1.1) If
     * there is (*,G) Join, clear join interface from the pruned_oifs for all
     * (S,G), but DO NOT flush the change to the kernel (by using
     * change_interfaces() for example) (3.2) After the pruned_oifs are
     * eventually cleared in (3.1.1), process the Prune part of the message
     * normally (setting the prune_oifs and flashing the changes to the
     * (kernel). (3.3) After the Prune part is processed, process the Join
     * part normally (by applying any changes to the kernel) (4) If there
     * were (*,*,RP) Join/Prune, process them.
     *
     * If the Join/Prune list is too long, it may result in long processing
     * overhead. The idea above is not to place any wrong info in the kernel,
     * because it may result in short-time existing traffic forwarding on
     * wrong interface. Hopefully, in the future will find a better way to
     * implement it.
     */

    IF_DEBUG(DEBUG_PIM_JOIN_PRUNE)
	log(LOG_DEBUG,0,"I'm the target of the JOIN/PRUNE message");

    num_groups_tmp = num_groups;
    data_ptr_start = data_ptr;
    star_star_rp_found = FALSE;	/* Indicating whether we have (*,*,RP) join */

    IF_DEBUG(DEBUG_PIM_JOIN_PRUNE)
	log(LOG_DEBUG,0,"Number of groups to process : %d",num_groups_tmp);

    while (num_groups_tmp--)
    {
	/* Search for (*,*,RP) Join */
	GET_EGADDR6(&encod_group, data_ptr);
	GET_HOSTSHORT(num_j_srcs, data_ptr);
	GET_HOSTSHORT(num_p_srcs, data_ptr);
	group.sin6_addr = encod_group.mcast_addr;
	group.sin6_scope_id = inet6_uvif2scopeid(&group, v);

   	IF_DEBUG(DEBUG_PIM_JOIN_PRUNE)
	{
		log(LOG_DEBUG, 0,
		    "Group to process : %s",inet6_fmt(&encod_group.mcast_addr));
		log(LOG_DEBUG, 0,
		    "Number of join   : %d",num_j_srcs );
		log(LOG_DEBUG, 0,
		    "Number of prune  : %d",num_p_srcs );
	}

	if (!(inet6_equal(&group,&sockaddr6_d))
	    || (encod_src.masklen != STAR_STAR_RP_MSK6LEN))
	{
	    /* This is not (*,*,RP). Jump to the next group. */
	    data_ptr += (num_j_srcs + num_p_srcs) * sizeof(pim6_encod_src_addr_t);
	    IF_DEBUG(DEBUG_PIM_JOIN_PRUNE)
		{
		    log(LOG_DEBUG, 0,
			"I'm looking for the (*,*,RP) entry , skip to next entry");
		}
	    continue;
	}

	/*
	 * (*,*,RP) found. For each RP and each (*,G) and each (S,G) clear
	 * the pruned oif, but do not update the kernel.
	 */

	star_star_rp_found = TRUE;
	while (num_j_srcs--)
	{
	    GET_ESADDR6(&encod_src, data_ptr);
	    source.sin6_addr = encod_src.src_addr;
	    rpentry_ptr = rp_find(&source);

	    if (rpentry_ptr == (rpentry_t *) NULL)
		continue;
	    for (rp_grp_entry_ptr = rpentry_ptr->cand_rp->rp_grp_next;
		 rp_grp_entry_ptr != (rp_grp_entry_t *) NULL;
		 rp_grp_entry_ptr = rp_grp_entry_ptr->rp_grp_next)
	    {
		for (grpentry_ptr = rp_grp_entry_ptr->grplink;
		     grpentry_ptr != (grpentry_t *) NULL;
		     grpentry_ptr = grpentry_ptr->rpnext)
		{
		    if (grpentry_ptr->grp_route != (mrtentry_t *) NULL)
			IF_CLR(mifi, &grpentry_ptr->grp_route->pruned_oifs);
		    for (mrtentry_ptr = grpentry_ptr->mrtlink;
			 mrtentry_ptr != (mrtentry_t *) NULL;
			 mrtentry_ptr = mrtentry_ptr->grpnext)
			IF_CLR(mifi, &mrtentry_ptr->pruned_oifs);
		}
	    }
	}
	data_ptr += (num_p_srcs) * sizeof(pim6_encod_src_addr_t);
    }

    /*
     * Start processing the groups. If this is (*,*,RP), skip it, but process
     * it at the end.don't forget to reinit data_ptr!
     */

    data_ptr = data_ptr_start;
    num_groups_tmp = num_groups;

    while (num_groups_tmp--)
    {
	GET_EGADDR6(&encod_group, data_ptr);
	GET_HOSTSHORT(num_j_srcs, data_ptr);
	GET_HOSTSHORT(num_p_srcs, data_ptr);
	group.sin6_addr = encod_group.mcast_addr;
	group.sin6_scope_id = inet6_uvif2scopeid(&group, v);

 	IF_DEBUG(DEBUG_PIM_JOIN_PRUNE)
	{
		log(LOG_DEBUG,0,"Group to process : %s",inet6_fmt(&encod_group.mcast_addr));
		log(LOG_DEBUG,0,"Number of join   : %d",num_j_srcs );
		log(LOG_DEBUG,0,"Number of prune  : %d",num_p_srcs );
	}

	if (!IN6_IS_ADDR_MULTICAST(&group.sin6_addr))
	{
	    data_ptr += (num_j_srcs + num_p_srcs) * sizeof(pim6_encod_src_addr_t);
	    continue;		/* Ignore this group and jump to the next one */
	}


	if (inet6_equal(&group, &sockaddr6_d)
	    && (encod_group.masklen == STAR_STAR_RP_MSK6LEN))
	{
	    /* This is (*,*,RP). Jump to the next group. */
	    IF_DEBUG(DEBUG_PIM_JOIN_PRUNE) {
		    log(LOG_DEBUG, 0, "This is (*,*,RP). Jump to next.");
	    }
	    data_ptr += (num_j_srcs + num_p_srcs) * sizeof(pim6_encod_src_addr_t);
	    continue;
	}

	rpentry_ptr = rp_match(&group);
	if (rpentry_ptr == (rpentry_t *) NULL)
	    continue;

	IF_DEBUG(DEBUG_PIM_JOIN_PRUNE)
		log(LOG_DEBUG,0,"The rp for this JOIN/PRUNE is %s",inet6_fmt(&rpentry_ptr->address.sin6_addr));

	data_ptr_group_j_start = data_ptr;
	data_ptr_group_p_start = data_ptr + num_j_srcs * sizeof(pim6_encod_src_addr_t);

	/*
	 * Scan the Join part for (*,G) Join and then clear the particular
	 * interface from pruned_oifs for all (S,G). If the RP address in the
	 * Join message is different from the local match, ignore the whole
	 * group.
	 */

	num_j_srcs_tmp = num_j_srcs;
	ignore_group = FALSE;

	while (num_j_srcs_tmp--)
	{
	    GET_ESADDR6(&encod_src, data_ptr);
	    source.sin6_addr=encod_src.src_addr;
	    source.sin6_scope_id = inet6_uvif2scopeid(&source,v);

   	    if ((encod_src.flags & USADDR_RP_BIT)
		&& (encod_src.flags & USADDR_WC_BIT))
	    {
		/*
		 * This is the RP address, i.e. (*,G) Join. Check if the
		 * RP-mapping is consistent and if "yes", then Reset the
		 * pruned_oifs for all (S,G) entries.
		 */

		if(!inet6_equal(&rpentry_ptr->address, &source))
		{
		    ignore_group = TRUE;
		    IF_DEBUG(DEBUG_PIM_JOIN_PRUNE)
			log(LOG_DEBUG,0,"And I'm not the RP for this address");
		    break;
		}

		mrtentry_ptr = find_route(&sockaddr6_any, &group,
					  MRTF_WC, DONT_CREATE);

		if (mrtentry_ptr != (mrtentry_t *) NULL)
		{
		    for (mrtentry_srcs = mrtentry_ptr->group->mrtlink;
			 mrtentry_srcs != (mrtentry_t *) NULL;
			 mrtentry_srcs = mrtentry_srcs->grpnext)
			IF_CLR(mifi, &mrtentry_srcs->pruned_oifs);
		}
		break;
	    }
	}

	if (ignore_group == TRUE)
	    continue;

	data_ptr = data_ptr_group_p_start;

	/* Process the Prune part first */

	while (num_p_srcs--)
	{
	    GET_ESADDR6(&encod_src, data_ptr);
	    source.sin6_addr = encod_src.src_addr;
	    source.sin6_scope_id = inet6_uvif2scopeid(&source, v);

	    if (!inet6_valid_host(&source))
		continue;
	    s_flags = encod_src.flags;
	    if (!(s_flags & (USADDR_WC_BIT | USADDR_RP_BIT)))
	    {
		/* (S,G) prune sent toward S */
		mrtentry_ptr = find_route(&source, &group, MRTF_SG,
					  DONT_CREATE);
		if (mrtentry_ptr == (mrtentry_t *) NULL)
		    continue;	/* I don't have (S,G) to prune. Ignore. */
		/*
		 * If the link is point-to-point, timeout the oif
		 * immediately, otherwise decrease the timer to allow other
		 * downstream routers to override the prune.
		 */
		/* TODO: XXX: increase the entry timer? */

		if (v->uv_flags & VIFF_POINT_TO_POINT)
		{
		    FIRE_TIMER(mrtentry_ptr->vif_timers[mifi]);
		}
		else
		{
		    /* TODO: XXX: TIMER implem. dependency! */
		    if (mrtentry_ptr->vif_timers[mifi] >
			mrtentry_ptr->vif_deletion_delay[mifi])
			SET_TIMER(mrtentry_ptr->vif_timers[mifi],
				  mrtentry_ptr->vif_deletion_delay[mifi]);
		}
		IF_TIMER_NOT_SET(mrtentry_ptr->vif_timers[mifi])
		{
		    IF_CLR(mifi, &mrtentry_ptr->joined_oifs);
		    IF_SET(mifi, &mrtentry_ptr->pruned_oifs);
		    change_interfaces(mrtentry_ptr,
				      mrtentry_ptr->incoming,
				      &mrtentry_ptr->joined_oifs,
				      &mrtentry_ptr->pruned_oifs,
				      &mrtentry_ptr->leaves,
				      &mrtentry_ptr->asserted_oifs, 0);
		}
		continue;
	    }

	    if ((s_flags & USADDR_RP_BIT)
		&& (!(s_flags & USADDR_WC_BIT)))
	    {
		/* ~(S,G)RPbit prune sent toward the RP */
		mrtentry_ptr = find_route(&source, &group, MRTF_SG,
					  DONT_CREATE);
		if (mrtentry_ptr != (mrtentry_t *) NULL)
		{
		    SET_TIMER(mrtentry_ptr->timer, holdtime);
		    if (v->uv_flags & VIFF_POINT_TO_POINT)
		    {
			FIRE_TIMER(mrtentry_ptr->vif_timers[mifi]);
		    }
		    else
		    {
			/* TODO: XXX: TIMER implem. dependency! */
			if (mrtentry_ptr->vif_timers[mifi] >
			    mrtentry_ptr->vif_deletion_delay[mifi])
			    SET_TIMER(mrtentry_ptr->vif_timers[mifi],
				    mrtentry_ptr->vif_deletion_delay[mifi]);
		    }
		    IF_TIMER_NOT_SET(mrtentry_ptr->vif_timers[mifi])
		    {
			IF_CLR(mifi, &mrtentry_ptr->joined_oifs);
			IF_SET(mifi, &mrtentry_ptr->pruned_oifs);
			change_interfaces(mrtentry_ptr,
					  mrtentry_ptr->incoming,
					  &mrtentry_ptr->joined_oifs,
					  &mrtentry_ptr->pruned_oifs,
					  &mrtentry_ptr->leaves,
					  &mrtentry_ptr->asserted_oifs, 0);
		    }
		    continue;
		}
		/* There is no (S,G) entry. Check for (*,G) or (*,*,RP) */
		mrtentry_ptr = find_route(NULL, &group,
					  MRTF_WC | MRTF_PMBR,
					  DONT_CREATE);
		if (mrtentry_ptr != (mrtentry_t *) NULL)
		{
		    mrtentry_ptr = find_route(&source, &group,
					      MRTF_SG | MRTF_RP,
					      CREATE);
		    if (mrtentry_ptr == (mrtentry_t *) NULL)
			continue;
		    mrtentry_ptr->flags &= ~MRTF_NEW;
		    RESET_TIMER(mrtentry_ptr->vif_timers[mifi]);

		    /*
		     * TODO: XXX: The spec doens't say what value to use for
		     * the entry time. Use the J/P holdtime.
		     */

		    SET_TIMER(mrtentry_ptr->timer, holdtime);

		    /*
		     * TODO: XXX: The spec says to delete the oif. However,
		     * its timer only should be lowered, so the prune can be
		     * overwritten on multiaccess LAN. Spec BUG.
		     */

		    IF_CLR(mifi, &mrtentry_ptr->joined_oifs);
		    IF_SET(mifi, &mrtentry_ptr->pruned_oifs);
		    change_interfaces(mrtentry_ptr,
				      mrtentry_ptr->incoming,
				      &mrtentry_ptr->joined_oifs,
				      &mrtentry_ptr->pruned_oifs,
				      &mrtentry_ptr->leaves,
				      &mrtentry_ptr->asserted_oifs, 0);
		}
		continue;
	    }

	    if ((s_flags & USADDR_RP_BIT) && (s_flags & USADDR_WC_BIT))
	    {
		/* (*,G) Prune */
		mrtentry_ptr = find_route(NULL, &group,
					  MRTF_WC | MRTF_PMBR,
					  DONT_CREATE);
		if (mrtentry_ptr != (mrtentry_t *) NULL)
		{
		    if (mrtentry_ptr->flags & MRTF_WC)
		    {
			/*
			 * TODO: XXX: Should check the whole Prune list in
			 * advance for (*,G) prune and if the RP address does
			 * not match the local RP-map, then ignore the whole
			 * group, not only this particular (*,G) prune.
			 */
			if (!inet6_equal(&mrtentry_ptr->group->active_rp_grp->rp->rpentry->address, &source ))
			    continue;	/* The RP address doesn't match. */
			if (v->uv_flags & VIFF_POINT_TO_POINT)
			{
			    FIRE_TIMER(mrtentry_ptr->vif_timers[mifi]);
			}
			else
			{
			    /* TODO: XXX: TIMER implem. dependency! */
			    if (mrtentry_ptr->vif_timers[mifi] >
				mrtentry_ptr->vif_deletion_delay[mifi])
				SET_TIMER(mrtentry_ptr->vif_timers[mifi],
				    mrtentry_ptr->vif_deletion_delay[mifi]);
			}
			IF_TIMER_NOT_SET(mrtentry_ptr->vif_timers[mifi])
			{
			    IF_CLR(mifi, &mrtentry_ptr->joined_oifs);
			    IF_SET(mifi, &mrtentry_ptr->pruned_oifs);
			    change_interfaces(mrtentry_ptr,
					      mrtentry_ptr->incoming,
					      &mrtentry_ptr->joined_oifs,
					      &mrtentry_ptr->pruned_oifs,
					      &mrtentry_ptr->leaves,
					      &mrtentry_ptr->asserted_oifs, 0);
			}
			continue;
		    }
		    /* No (*,G) entry, but found (*,*,RP). Create (*,G) */
		    if (!inet6_equal(&mrtentry_ptr->source->address, &source))
			continue;	/* The RP address doesn't match. */
		    mrtentry_ptr = find_route(NULL, &group,
					      MRTF_WC, CREATE);
		    if (mrtentry_ptr == (mrtentry_t *) NULL)
			continue;
		    mrtentry_ptr->flags &= ~MRTF_NEW;
		    RESET_TIMER(mrtentry_ptr->vif_timers[mifi]);

		    /*
		     * TODO: XXX: should only lower the oif timer, so it can
		     * be overwritten on multiaccess LAN. Spec bug.
		     */

		    IF_CLR(mifi, &mrtentry_ptr->joined_oifs);
		    IF_SET(mifi, &mrtentry_ptr->pruned_oifs);
		    change_interfaces(mrtentry_ptr,
				      mrtentry_ptr->incoming,
				      &mrtentry_ptr->joined_oifs,
				      &mrtentry_ptr->pruned_oifs,
				      &mrtentry_ptr->leaves,
				      &mrtentry_ptr->asserted_oifs, 0);
		}		/* (*,G) or (*,*,RP) found */
	    }			/* (*,G) prune */
	}			/* while(num_p_srcs--) */

	/* End of (S,G) and (*,G) Prune handling */

	/* Jump back to the Join part and process it */
	data_ptr = data_ptr_group_j_start;
	while (num_j_srcs--)
	{
	    GET_ESADDR6(&encod_src, data_ptr);
	    source.sin6_addr = encod_src.src_addr;
	    source.sin6_scope_id = inet6_uvif2scopeid(&source, v);

	    if (!inet6_valid_host(&source))
		continue;
	    s_flags = encod_src.flags;
	    MASKLEN_TO_MASK6(encod_src.masklen, s_mask);
	    if ((s_flags & USADDR_WC_BIT)
		&& (s_flags & USADDR_RP_BIT))
	    {
		/* (*,G) Join toward RP */
		/*
		 * It has been checked already that this RP address is the
		 * same as the local RP-maping.
		 */
		mrtentry_ptr = find_route(NULL, &group, MRTF_WC,
					  CREATE);
		if (mrtentry_ptr == (mrtentry_t *) NULL)
		    continue;
		IF_SET(mifi, &mrtentry_ptr->joined_oifs);
		IF_CLR(mifi, &mrtentry_ptr->pruned_oifs);
		IF_CLR(mifi, &mrtentry_ptr->asserted_oifs);
		/* TODO: XXX: TIMER implem. dependency! */
		if (mrtentry_ptr->vif_timers[mifi] < holdtime)
		{
		    SET_TIMER(mrtentry_ptr->vif_timers[mifi], holdtime);
		    mrtentry_ptr->vif_deletion_delay[mifi] = holdtime / 3;
		}
		if (mrtentry_ptr->timer < holdtime)
		    SET_TIMER(mrtentry_ptr->timer, holdtime);
		mrtentry_ptr->flags &= ~MRTF_NEW;
		change_interfaces(mrtentry_ptr,
				  mrtentry_ptr->incoming,
				  &mrtentry_ptr->joined_oifs,
				  &mrtentry_ptr->pruned_oifs,
				  &mrtentry_ptr->leaves,
				  &mrtentry_ptr->asserted_oifs, 0);
		/*
		 * Need to update the (S,G) entries, because of the previous
		 * cleaning of the pruned_oifs. The reason is that if the
		 * oifs for (*,G) weren't changed, the (S,G) entries won't be
		 * updated by change_interfaces()
		 */

		for (mrtentry_srcs = mrtentry_ptr->group->mrtlink;
		     mrtentry_srcs != (mrtentry_t *) NULL;
		     mrtentry_srcs = mrtentry_srcs->grpnext)
		    change_interfaces(mrtentry_srcs,
				      mrtentry_srcs->incoming,
				      &mrtentry_srcs->joined_oifs,
				      &mrtentry_srcs->pruned_oifs,
				      &mrtentry_srcs->leaves,
				      &mrtentry_srcs->asserted_oifs, 0);
		continue;
	    }

	    if (!(s_flags & (USADDR_WC_BIT | USADDR_RP_BIT)))
	    {
		/* (S,G) Join toward S */
		if (mifi == get_iif(&source))
		    continue;	/* Ignore this (S,G) Join */
		mrtentry_ptr = find_route(&source, &group, MRTF_SG, CREATE);
		if (mrtentry_ptr == (mrtentry_t *) NULL)
		    continue;
		IF_SET(mifi, &mrtentry_ptr->joined_oifs);
		IF_CLR(mifi, &mrtentry_ptr->pruned_oifs);
		IF_CLR(mifi, &mrtentry_ptr->asserted_oifs);
		/* TODO: XXX: TIMER implem. dependency! */
		if (mrtentry_ptr->vif_timers[mifi] < holdtime)
		{
		    SET_TIMER(mrtentry_ptr->vif_timers[mifi], holdtime);
		    mrtentry_ptr->vif_deletion_delay[mifi] = holdtime / 3;
		}
		if (mrtentry_ptr->timer < holdtime)
		    SET_TIMER(mrtentry_ptr->timer, holdtime);
		/*
		 * TODO: if this is a new entry, send immediately the Join
		 * message toward S. The Join/Prune timer for new entries is
		 * 0, but it does not means the message will be sent
		 * immediately.
		 */
		mrtentry_ptr->flags &= ~MRTF_NEW;
		/*
		 * Note that we must create (S,G) without the RPbit set. If
		 * we already had such entry, change_interfaces() will reset
		 * the RPbit propertly.
		 */
		change_interfaces(mrtentry_ptr,
				  mrtentry_ptr->source->incoming,
				  &mrtentry_ptr->joined_oifs,
				  &mrtentry_ptr->pruned_oifs,
				  &mrtentry_ptr->leaves,
				  &mrtentry_ptr->asserted_oifs, 0);
		continue;
	    }
	}			/* while(num_j_srcs--) */
    }				/* for all groups */

    /* Now process the (*,*,RP) Join/Prune */

    if (star_star_rp_found == TRUE)
	return (TRUE);
    data_ptr = data_ptr_start;
    while (num_groups--)
    {
	/*
	 * The conservative approach is to scan again the whole message, just
	 * in case if we have more than one (*,*,RP) requests.
	 */
	GET_EGADDR6(&encod_group, data_ptr);
	GET_HOSTSHORT(num_j_srcs, data_ptr);
	GET_HOSTSHORT(num_p_srcs, data_ptr);

	group.sin6_addr = encod_group.mcast_addr;
	group.sin6_scope_id = inet6_uvif2scopeid(&group, v);

	if (!inet6_equal(&group,&sockaddr6_d)
	    || (encod_group.masklen != STAR_STAR_RP_MSK6LEN))
	{
	    /* This is not (*,*,RP). Jump to the next group. */
	    data_ptr +=
		(num_j_srcs + num_p_srcs) * sizeof(pim6_encod_src_addr_t);
	    continue;
	}
	/* (*,*,RP) found */
	while (num_j_srcs--)
	{
	    /* TODO: XXX: check that the iif is different from the Join oifs */
	    GET_ESADDR6(&encod_src, data_ptr);
	    source.sin6_addr = encod_src.src_addr;
	    source.sin6_scope_id = inet6_uvif2scopeid(&source,
                                      v);


	    if (!inet6_valid_host(&source))
		continue;
	    s_flags = encod_src.flags;
	    MASKLEN_TO_MASK6(encod_src.masklen, s_mask);
	    mrtentry_ptr = find_route(&source, NULL, MRTF_PMBR,
				      CREATE);
	    if (mrtentry_ptr == (mrtentry_t *) NULL)
		continue;
	    IF_SET(mifi, &mrtentry_ptr->joined_oifs);
	    IF_CLR(mifi, &mrtentry_ptr->pruned_oifs);
	    IF_CLR(mifi, &mrtentry_ptr->asserted_oifs);
	    /* TODO: XXX: TIMER implem. dependency! */
	    if (mrtentry_ptr->vif_timers[mifi] < holdtime)
	    {
		SET_TIMER(mrtentry_ptr->vif_timers[mifi], holdtime);
		mrtentry_ptr->vif_deletion_delay[mifi] = holdtime / 3;
	    }
	    if (mrtentry_ptr->timer < holdtime)
		SET_TIMER(mrtentry_ptr->timer, holdtime);
	    mrtentry_ptr->flags &= ~MRTF_NEW;
	    change_interfaces(mrtentry_ptr,
			      mrtentry_ptr->incoming,
			      &mrtentry_ptr->joined_oifs,
			      &mrtentry_ptr->pruned_oifs,
			      &mrtentry_ptr->leaves,
			      &mrtentry_ptr->asserted_oifs, 0);

	    /*
	     * Need to update the (S,G) and (*,G) entries, because of the
	     * previous cleaning of the pruned_oifs. The reason is that if
	     * the oifs for (*,*,RP) weren't changed, the (*,G) and (S,G)
	     * entries won't be updated by change_interfaces()
	     */

	    for (rp_grp_entry_ptr = mrtentry_ptr->source->cand_rp->rp_grp_next;
		 rp_grp_entry_ptr != (rp_grp_entry_t *) NULL;
		 rp_grp_entry_ptr = rp_grp_entry_ptr->rp_grp_next)
		for (grpentry_ptr = rp_grp_entry_ptr->grplink;
		     grpentry_ptr != (grpentry_t *) NULL;
		     grpentry_ptr = grpentry_ptr->rpnext)
		{
		    /* Update the (*,G) entry */
		    change_interfaces(grpentry_ptr->grp_route,
				      grpentry_ptr->grp_route->incoming,
				      &grpentry_ptr->grp_route->joined_oifs,
				      &grpentry_ptr->grp_route->pruned_oifs,
				      &grpentry_ptr->grp_route->leaves,
				 	  &grpentry_ptr->grp_route->asserted_oifs, 0);
		    /* Update the (S,G) entries */
		    for (mrtentry_srcs = grpentry_ptr->mrtlink;
			 mrtentry_srcs != (mrtentry_t *) NULL;
			 mrtentry_srcs = mrtentry_srcs->grpnext)
			change_interfaces(mrtentry_srcs,
					  mrtentry_srcs->incoming,
					  &mrtentry_srcs->joined_oifs,
					  &mrtentry_srcs->pruned_oifs,
					  &mrtentry_srcs->leaves,
					  &mrtentry_srcs->asserted_oifs, 0);
		}
	    continue;
	}

	while (num_p_srcs--)
	{
	    /* TODO: XXX: can we have (*,*,RP) Prune? */
	    GET_ESADDR6(&encod_src, data_ptr);
	    source.sin6_addr = encod_src.src_addr;
	    source.sin6_scope_id = inet6_uvif2scopeid(&source,
                                      v);

	    if (!inet6_valid_host(&source))
		continue;
	    s_flags = encod_src.flags;
	    MASKLEN_TO_MASK6(encod_src.masklen, s_mask);
	    mrtentry_ptr = find_route(&source, NULL , MRTF_PMBR,
				      DONT_CREATE);
	    if (mrtentry_ptr == (mrtentry_t *) NULL)
		continue;
	    /*
	     * If the link is point-to-point, timeout the oif immediately,
	     * otherwise decrease the timer to allow other downstream routers
	     * to override the prune.
	     */
	    /* TODO: XXX: increase the entry timer? */
	    if (v->uv_flags & VIFF_POINT_TO_POINT)
	    {
		FIRE_TIMER(mrtentry_ptr->vif_timers[mifi]);
	    }
	    else
	    {
		/* TODO: XXX: TIMER implem. dependency! */
		if (mrtentry_ptr->vif_timers[mifi] >
		    mrtentry_ptr->vif_deletion_delay[mifi])
		    SET_TIMER(mrtentry_ptr->vif_timers[mifi],
			      mrtentry_ptr->vif_deletion_delay[mifi]);
	    }
	    IF_TIMER_NOT_SET(mrtentry_ptr->vif_timers[mifi])
	    {
		IF_CLR(mifi, &mrtentry_ptr->joined_oifs);
		IF_SET(mifi, &mrtentry_ptr->pruned_oifs);
		IF_SET(mifi, &mrtentry_ptr->asserted_oifs);
		change_interfaces(mrtentry_ptr,
				  mrtentry_ptr->incoming,
				  &mrtentry_ptr->joined_oifs,
				  &mrtentry_ptr->pruned_oifs,
				  &mrtentry_ptr->leaves,
				  &mrtentry_ptr->asserted_oifs, 0);
	    }

	}
    }				/* For all groups processing (*,*,R) */

    return (TRUE);
}


/*
 * TODO: NOT USED, probably buggy, but may need it in the future.
 */
/*
 * TODO: create two functions: periodic which timeout the timers and
 * non-periodic which only check but don't timeout the timers.
 */
/*
 * Create and send Join/Prune messages per interface. Only the entries which
 * have the Join/Prune timer expired are included. In the special case when
 * we have ~(S,G)RPbit Prune entry, we must include any (*,G) or (*,*,RP)
 * Currently the whole table is scanned. In the future will have all routing
 * entries linked in a chain with the corresponding upstream pim_nbr_entry.
 *
 * If pim_nbr is not NULL, then send to only this particular PIM neighbor,
 */
int
send_periodic_pim6_join_prune(mifi, pim_nbr, holdtime)
    mifi_t          mifi;
    pim_nbr_entry_t *pim_nbr;
    u_int16         holdtime;
{
    grpentry_t     		*grpentry_ptr;
    mrtentry_t     		*mrtentry_ptr;
    rpentry_t      		*rpentry_ptr;
    struct sockaddr_in6   	src_addr;
    struct uvif    		*v;
    pim_nbr_entry_t 		*pim_nbr_ptr;
    cand_rp_t      		*cand_rp_ptr;

    /*
     * Walk through all routing entries. The iif must match to include the
     * entry. Check first the (*,G) entry and then all associated (S,G). At
     * the end of the message will add any (*,*,RP) entries. TODO: check
     * other PIM-SM implementations and decide the more appropriate place to
     * put the (*,*,RP) entries: in the beginning of the message or at the
     * end.
     */

    v = &uvifs[mifi];

    /* Check the (*,G) and (S,G) entries */
    for (grpentry_ptr = grplist; grpentry_ptr != (grpentry_t *) NULL;
	 grpentry_ptr = grpentry_ptr->next)
    {
	mrtentry_ptr = grpentry_ptr->grp_route;
	/* TODO: XXX: TIMER implem. dependency! */
	if ((mrtentry_ptr != (mrtentry_t *) NULL)
	    && (mrtentry_ptr->incoming == mifi)
	    && (mrtentry_ptr->jp_timer <= timer_interval))
	{

	    /* If join/prune to a particular neighbor only was specified */
	    if ((pim_nbr != (pim_nbr_entry_t *) NULL)
		&& (mrtentry_ptr->upstream != pim_nbr))
		continue;

	    /* TODO: XXX: The J/P suppression timer is not in the spec! */
	    if (!IF_ISEMPTY(&mrtentry_ptr->joined_oifs) ||
		(v->uv_flags & VIFF_DR))
	    {
		add_jp_entry(mrtentry_ptr->upstream, holdtime,
			     &grpentry_ptr->group,
			     SINGLE_GRP_MSK6LEN,
			     &grpentry_ptr->rpaddr,
			     SINGLE_SRC_MSK6LEN, 0, PIM_ACTION_JOIN);
	    }
	    /* TODO: XXX: TIMER implem. dependency! */
	    if (IF_ISEMPTY(&mrtentry_ptr->joined_oifs)
		&& (!(v->uv_flags & VIFF_DR))
		&& (mrtentry_ptr->jp_timer <= timer_interval))
	    {
		add_jp_entry(mrtentry_ptr->upstream, holdtime,
			     &grpentry_ptr->group, SINGLE_GRP_MSK6LEN,
			     &grpentry_ptr->rpaddr,
			     SINGLE_SRC_MSK6LEN, 0, PIM_ACTION_PRUNE);
	    }
	}

	/* Check the (S,G) entries */
	for (mrtentry_ptr = grpentry_ptr->mrtlink;
	     mrtentry_ptr != (mrtentry_t *) NULL;
	     mrtentry_ptr = mrtentry_ptr->grpnext)
	{

	    /* If join/prune to a particular neighbor only was specified */
	    if ((pim_nbr != (pim_nbr_entry_t *) NULL)
		&& (mrtentry_ptr->upstream != pim_nbr))
		continue;

	    if (mrtentry_ptr->flags & MRTF_RP)
	    {
		/* RPbit set */

		src_addr = mrtentry_ptr->source->address;
		if (IF_ISEMPTY(&mrtentry_ptr->joined_oifs)
		    || ((find_vif_direct_local(&src_addr) != NO_VIF)
			&& grpentry_ptr->grp_route != (mrtentry_t *) NULL))
		    /* TODO: XXX: TIMER implem. dependency! */
		    if ((grpentry_ptr->grp_route->incoming == mifi)
			&& (grpentry_ptr->grp_route->jp_timer
			    <= timer_interval))
			/* S is directly connected. Send toward RP */
			add_jp_entry(grpentry_ptr->grp_route->upstream,
				     holdtime,
				     &grpentry_ptr->group, SINGLE_GRP_MSK6LEN,
				     &src_addr, SINGLE_SRC_MSK6LEN,
				     MRTF_RP, PIM_ACTION_PRUNE);
	    }
	    else
	    {
		/* RPbit cleared */
		if (IF_ISEMPTY(&mrtentry_ptr->joined_oifs))
		{
		    /* TODO: XXX: TIMER implem. dependency! */
		    if ((mrtentry_ptr->incoming == mifi)
			&& (mrtentry_ptr->jp_timer <= timer_interval))
			add_jp_entry(mrtentry_ptr->upstream, holdtime,
				     &grpentry_ptr->group, SINGLE_GRP_MSK6LEN,
				     &mrtentry_ptr->source->address,
				     SINGLE_SRC_MSK6LEN, 0, PIM_ACTION_PRUNE);
		}
		else
		{
		    /* TODO: XXX: TIMER implem. dependency! */
		    if ((mrtentry_ptr->incoming == mifi)
			&& (mrtentry_ptr->jp_timer <= timer_interval))
			add_jp_entry(mrtentry_ptr->upstream, holdtime,
				     &grpentry_ptr->group, SINGLE_GRP_MSK6LEN,
				     &mrtentry_ptr->source->address,
				     SINGLE_SRC_MSK6LEN, 0, PIM_ACTION_JOIN);
		}
		/* TODO: XXX: TIMER implem. dependency! */
		if ((mrtentry_ptr->flags & MRTF_SPT)
		    && (grpentry_ptr->grp_route != (mrtentry_t *) NULL)
		    && (mrtentry_ptr->incoming !=
			grpentry_ptr->grp_route->incoming)
		    && (grpentry_ptr->grp_route->incoming == mifi)
		    && (grpentry_ptr->grp_route->jp_timer
			<= timer_interval))
		    add_jp_entry(grpentry_ptr->grp_route->upstream, holdtime,
				 &grpentry_ptr->group, SINGLE_GRP_MSK6LEN,
				 &mrtentry_ptr->source->address,
				 SINGLE_SRC_MSK6LEN, MRTF_RP,
				 PIM_ACTION_PRUNE);
	    }
	}
    }

    /* Check the (*,*,RP) entries */
    for (cand_rp_ptr = cand_rp_list; cand_rp_ptr != (cand_rp_t *) NULL;
	 cand_rp_ptr = cand_rp_ptr->next)
    {
	rpentry_ptr = cand_rp_ptr->rpentry;

	/* If join/prune to a particular neighbor only was specified */
	if ((pim_nbr != (pim_nbr_entry_t *) NULL)
	    && (rpentry_ptr->upstream != pim_nbr))
	    continue;


	/* TODO: XXX: TIMER implem. dependency! */
	if ((rpentry_ptr->mrtlink != (mrtentry_t *) NULL)
	    && (rpentry_ptr->incoming == mifi)
	    && (rpentry_ptr->mrtlink->jp_timer <= timer_interval))
	{
	    add_jp_entry(rpentry_ptr->upstream, holdtime,
			 &sockaddr6_d, STAR_STAR_RP_MSK6LEN,
			 &rpentry_ptr->address,
			 SINGLE_SRC_MSK6LEN, MRTF_RP | MRTF_WC,
			 PIM_ACTION_JOIN);
	}
    }

    /* Send all pending Join/Prune messages */
    for (pim_nbr_ptr = v->uv_pim_neighbors;
	 pim_nbr_ptr != (pim_nbr_entry_t *) NULL;
	 pim_nbr_ptr = pim_nbr->next)
    {

	/* If join/prune to a particular neighbor only was specified */
	if ((pim_nbr != (pim_nbr_entry_t *) NULL)
	    && (pim_nbr_ptr != pim_nbr))
	    continue;

	pack_and_send_jp6_message(pim_nbr_ptr);
    }

    return (TRUE);
}


int
add_jp_entry(pim_nbr, holdtime, group, grp_msklen, source, src_msklen,
	     addr_flags, join_prune)
    pim_nbr_entry_t 		*pim_nbr;
    u_int16         		holdtime;
    struct sockaddr_in6         *group;
    u_int8          		grp_msklen;
    struct sockaddr_in6         *source;
    u_int8          		src_msklen;
    u_int16         		addr_flags;
    u_int8          		join_prune;
{
    build_jp_message_t 		*bjpm;
    u_int8         		*data_ptr;
    u_int8          		flags = 0;
    int             		rp_flag;


    bjpm = pim_nbr->build_jp_message;

    if (bjpm != (build_jp_message_t *) NULL)
    {
	if ((bjpm->jp_message_size + bjpm->join_list_size +
	     bjpm->prune_list_size + bjpm->rp_list_join_size +
	     bjpm->rp_list_prune_size >= MAX_JP_MESSAGE_SIZE)
	    || (bjpm->join_list_size >= MAX_JOIN_LIST_SIZE)
	    || (bjpm->prune_list_size >= MAX_PRUNE_LIST_SIZE)
	    || (bjpm->rp_list_join_size >= MAX_JOIN_LIST_SIZE)
	    || (bjpm->rp_list_prune_size >= MAX_PRUNE_LIST_SIZE))
	{
	    /*
	     * TODO: XXX: BUG: If the list is getting too large, must be
	     * careful with the fragmentation.
	     */
	    pack_and_send_jp6_message(pim_nbr);
	    bjpm = pim_nbr->build_jp_message;	/* The buffer will be freed */
	}
    }

    if (bjpm != (build_jp_message_t *) NULL)
    {
	if ((!inet6_equal(&bjpm->curr_group, group)
	    || (bjpm->curr_group_msklen != grp_msklen)
	    || (bjpm->holdtime != holdtime)))
	{
	    pack_jp6_message(pim_nbr);
	}
    }

    if (bjpm == (build_jp_message_t *) NULL)
    {
	bjpm = get_jp6_working_buff();
	pim_nbr->build_jp_message = bjpm;
	data_ptr = bjpm->jp_message;
	PUT_EUADDR6(pim_nbr->address.sin6_addr, data_ptr);
	PUT_BYTE(0, data_ptr);	/* Reserved */
	bjpm->num_groups_ptr = data_ptr++;	/* The pointer for numgroups */
	*(bjpm->num_groups_ptr) = 0;	/* Zero groups */
	PUT_HOSTSHORT(holdtime, data_ptr);
	bjpm->holdtime = holdtime;
	bjpm->jp_message_size = data_ptr - bjpm->jp_message;
    }

    /* TODO: move somewhere else, only when it is a new group */
    bjpm->curr_group = *group;
    bjpm->curr_group_msklen = grp_msklen;

    if (inet6_equal(group, &sockaddr6_d) &&
	(grp_msklen == STAR_STAR_RP_MSK6LEN))
	rp_flag = TRUE;
    else
	rp_flag = FALSE;

    switch (join_prune)
    {
    case PIM_ACTION_JOIN:
	if (rp_flag == TRUE)
	    data_ptr = bjpm->rp_list_join + bjpm->rp_list_join_size;
	else
	    data_ptr = bjpm->join_list + bjpm->join_list_size;
	break;
    case PIM_ACTION_PRUNE:
	if (rp_flag == TRUE)
	    data_ptr = bjpm->rp_list_join + bjpm->rp_list_join_size;
	else
	    data_ptr = bjpm->prune_list + bjpm->prune_list_size;
	break;
    default:
	return (FALSE);
    }

    flags |= USADDR_S_BIT;	/* Mandatory for PIMv2 */
    if (addr_flags & MRTF_RP)
	flags |= USADDR_RP_BIT;
    if (addr_flags & MRTF_WC)
	flags |= USADDR_WC_BIT;
    PUT_ESADDR6(source->sin6_addr, src_msklen, flags, data_ptr);

    switch (join_prune)
    {
    case PIM_ACTION_JOIN:
	if (rp_flag == TRUE)
	{
	    bjpm->rp_list_join_size = data_ptr - bjpm->rp_list_join;
	    bjpm->rp_list_join_number++;
	}
	else
	{
	    bjpm->join_list_size = data_ptr - bjpm->join_list;
	    bjpm->join_addr_number++;
	}
	break;
    case PIM_ACTION_PRUNE:
	if (rp_flag == TRUE)
	{
	    bjpm->rp_list_prune_size = data_ptr - bjpm->rp_list_prune;
	    bjpm->rp_list_prune_number++;
	}
	else
	{
	    bjpm->prune_list_size = data_ptr - bjpm->prune_list;
	    bjpm->prune_addr_number++;
	}
	break;
    default:
	return (FALSE);
    }

    return (TRUE);
}


/* TODO: check again the size of the buffers */

static build_jp_message_t *
get_jp6_working_buff()
{
    build_jp_message_t *bjpm_ptr;

    if (build_jp_message_pool_counter == 0)
    {
	bjpm_ptr = (build_jp_message_t *) malloc(sizeof(build_jp_message_t));
	bjpm_ptr->next = (build_jp_message_t *) NULL;
	bjpm_ptr->jp_message =
	    (u_int8 *) malloc(MAX_JP_MESSAGE_SIZE +
			      sizeof(pim_jp_encod_grp_t) +
			      2 * sizeof(pim6_encod_src_addr_t));
	bjpm_ptr->jp_message_size = 0;
	bjpm_ptr->join_list_size = 0;
	bjpm_ptr->join_addr_number = 0;
	bjpm_ptr->join_list = (u_int8 *) malloc(MAX_JOIN_LIST_SIZE +
					      sizeof(pim6_encod_src_addr_t));
	bjpm_ptr->prune_list_size = 0;
	bjpm_ptr->prune_addr_number = 0;
	bjpm_ptr->prune_list = (u_int8 *) malloc(MAX_PRUNE_LIST_SIZE +
					      sizeof(pim6_encod_src_addr_t));
	bjpm_ptr->rp_list_join_size = 0;
	bjpm_ptr->rp_list_join_number = 0;
	bjpm_ptr->rp_list_join = (u_int8 *) malloc(MAX_JOIN_LIST_SIZE +
					      sizeof(pim6_encod_src_addr_t));
	bjpm_ptr->rp_list_prune_size = 0;
	bjpm_ptr->rp_list_prune_number = 0;
	bjpm_ptr->rp_list_prune = (u_int8 *) malloc(MAX_PRUNE_LIST_SIZE +
					      sizeof(pim6_encod_src_addr_t));
	bjpm_ptr->curr_group = sockaddr6_any;
	bjpm_ptr->curr_group_msklen = 0;
	bjpm_ptr->holdtime = 0;
	return bjpm_ptr;
    }
    else
    {
	bjpm_ptr = build_jp_message_pool;
	build_jp_message_pool = build_jp_message_pool->next;
	build_jp_message_pool_counter--;
	bjpm_ptr->jp_message_size = 0;
	bjpm_ptr->join_list_size = 0;
	bjpm_ptr->join_addr_number = 0;
	bjpm_ptr->prune_list_size = 0;
	bjpm_ptr->prune_addr_number = 0;
	bjpm_ptr->curr_group = sockaddr6_any;
	bjpm_ptr->curr_group_msklen = 0;
	return (bjpm_ptr);
    }
}


static void
return_jp6_working_buff(pim_nbr)
    pim_nbr_entry_t *pim_nbr;
{
    build_jp_message_t *bjpm_ptr = pim_nbr->build_jp_message;

    if (bjpm_ptr == (build_jp_message_t *) NULL)
	return;
    /* Don't waste memory by keeping too many free buffers */
    /* TODO: check/modify the definitions for POOL_NUMBER and size */
    if (build_jp_message_pool_counter >= MAX_JP_MESSAGE_POOL_NUMBER)
    {
	free((void *) bjpm_ptr->jp_message);
	free((void *) bjpm_ptr->join_list);
	free((void *) bjpm_ptr->prune_list);
	free((void *) bjpm_ptr->rp_list_join);
	free((void *) bjpm_ptr->rp_list_prune);
	free((void *) bjpm_ptr);
    }
    else
    {
	bjpm_ptr->next = build_jp_message_pool;
	build_jp_message_pool = bjpm_ptr;
	build_jp_message_pool_counter++;
    }
    pim_nbr->build_jp_message = (build_jp_message_t *) NULL;
}


/*
 * TODO: XXX: Currently, the (*,*,RP) stuff goes at the end of the Join/Prune
 * message. However, this particular implementation of PIM processes the
 * Join/Prune messages faster if (*,*,RP) is at the beginning. Modify some of
 * the functions below such that the outgoing messages place (*,*,RP) at the
 * beginning, not at the end.
 */

static void
pack_jp6_message(pim_nbr)
    pim_nbr_entry_t *pim_nbr;
{
    build_jp_message_t *bjpm;
    u_int8         *data_ptr;

    bjpm = pim_nbr->build_jp_message;
    if ((bjpm == (build_jp_message_t *) NULL)
	|| (inet6_equal(&bjpm->curr_group,&sockaddr6_any)))
	return;
    data_ptr = bjpm->jp_message + bjpm->jp_message_size;
    PUT_EGADDR6(bjpm->curr_group.sin6_addr, bjpm->curr_group_msklen, 0, data_ptr);
    PUT_HOSTSHORT(bjpm->join_addr_number, data_ptr);
    PUT_HOSTSHORT(bjpm->prune_addr_number, data_ptr);
    bcopy(bjpm->join_list, data_ptr, bjpm->join_list_size);
    data_ptr += bjpm->join_list_size;
    bcopy(bjpm->prune_list, data_ptr, bjpm->prune_list_size);
    data_ptr += bjpm->prune_list_size;
    bjpm->jp_message_size = (data_ptr - bjpm->jp_message);
    bjpm->join_list_size = 0;
    bjpm->join_addr_number = 0;
#if 0				/* isn't this necessary? */
    bjpm->rp_list_join_size = 0;
    bjpm->rp_list_join_number = 0;
#endif
    bjpm->prune_list_size = 0;
    bjpm->prune_addr_number = 0;
#if 0				/* isn't this necessary? */
    bjpm->rp_list_prune_size = 0;
    bjpm->rp_list_prune_number = 0;
#endif
    (*bjpm->num_groups_ptr)++;
    bjpm->curr_group = sockaddr6_any;
    bjpm->curr_group_msklen = 0;
    if (*bjpm->num_groups_ptr == ((u_int8) ~ 0 - 1))
    {
	if (bjpm->rp_list_join_number + bjpm->rp_list_prune_number)
	{
	    /* Add the (*,*,RP) at the end */
	    data_ptr = bjpm->jp_message + bjpm->jp_message_size;
	    PUT_EGADDR6(sockaddr6_d.sin6_addr, STAR_STAR_RP_MSK6LEN, 0, data_ptr);
	    PUT_HOSTSHORT(bjpm->rp_list_join_number, data_ptr);
	    PUT_HOSTSHORT(bjpm->rp_list_prune_number, data_ptr);
	    bcopy(bjpm->rp_list_join, data_ptr, bjpm->rp_list_join_size);
	    data_ptr += bjpm->rp_list_join_size;
	    bcopy(bjpm->rp_list_prune, data_ptr, bjpm->rp_list_prune_size);
	    data_ptr += bjpm->rp_list_prune_size;
	    bjpm->jp_message_size = (data_ptr - bjpm->jp_message);
	    bjpm->rp_list_join_size = 0;
	    bjpm->rp_list_join_number = 0;
	    bjpm->rp_list_prune_size = 0;
	    bjpm->rp_list_prune_number = 0;
	    (*bjpm->num_groups_ptr)++;
	}
	send_jp6_message(pim_nbr);
    }
}

void
pack_and_send_jp6_message(pim_nbr)
    pim_nbr_entry_t *pim_nbr;
{
    u_int8         	*data_ptr;
    build_jp_message_t 	*bjpm;


    if ((pim_nbr == (pim_nbr_entry_t *) NULL)
     || ((bjpm = pim_nbr->build_jp_message) == (build_jp_message_t *) NULL))
	{
		return;
	}
    pack_jp6_message(pim_nbr);


    if (bjpm->rp_list_join_number + bjpm->rp_list_prune_number)
    {
	/* Add the (*,*,RP) at the end */
	data_ptr = bjpm->jp_message + bjpm->jp_message_size;

	PUT_EGADDR6(sockaddr6_d.sin6_addr, STAR_STAR_RP_MSK6LEN, 0, data_ptr);
	PUT_HOSTSHORT(bjpm->rp_list_join_number, data_ptr);
	PUT_HOSTSHORT(bjpm->rp_list_prune_number, data_ptr);
	bcopy(bjpm->rp_list_join, data_ptr, bjpm->rp_list_join_size);
	data_ptr += bjpm->rp_list_join_size;
	bcopy(bjpm->rp_list_prune, data_ptr, bjpm->rp_list_prune_size);
	data_ptr += bjpm->rp_list_prune_size;
	bjpm->jp_message_size = (data_ptr - bjpm->jp_message);
	bjpm->rp_list_join_size = 0;
	bjpm->rp_list_join_number = 0;
	bjpm->rp_list_prune_size = 0;
	bjpm->rp_list_prune_number = 0;
	(*bjpm->num_groups_ptr)++;
    }
    send_jp6_message(pim_nbr);
}

static void
send_jp6_message(pim_nbr)
    pim_nbr_entry_t *pim_nbr;
{
    u_int16         datalen;
    mifi_t          mifi;

    datalen = pim_nbr->build_jp_message->jp_message_size;
    mifi = pim_nbr->vifi;
    bcopy(pim_nbr->build_jp_message->jp_message,
	  pim6_send_buf+sizeof(struct pim), datalen);

    send_pim6(pim6_send_buf, &uvifs[mifi].uv_linklocal->pa_addr,
	      &allpim6routers_group , PIM_JOIN_PRUNE, datalen);
    uvifs[mifi].uv_out_pim6_join_prune++;
    return_jp6_working_buff(pim_nbr);
}

/************************************************************************
 *                        PIM_ASSERT
 ************************************************************************/
int
receive_pim6_assert(src, dst, pim_message, datalen)
    struct sockaddr_in6 	*src,
                    		*dst;
    register char  		*pim_message;
    int             		datalen;
{
    mifi_t          		mifi;
    pim6_encod_uni_addr_t 	eusaddr;
    pim6_encod_grp_addr_t 	egaddr;
    struct sockaddr_in6		source,
                    		group;
    mrtentry_t     		*mrtentry_ptr,
                   		*mrtentry_ptr2;
    u_int8         		*data_ptr;
    struct uvif    		*v;
    u_int32         		assert_preference;
    u_int32         		assert_metric;
    u_int32         		assert_rptbit;
    u_int32         		local_metric;
    u_int32         		local_preference;
    u_int8          		local_rptbit;
    u_int8          		local_wins;
    pim_nbr_entry_t 		*original_upstream_router;


    if ((mifi = find_vif_direct(src)) == NO_VIF)
    {
	/*
	 * Either a local vif or somehow received PIM_ASSERT from
	 * non-directly connected router. Ignore it.
	 */

	if (local_address(src) == NO_VIF)
	    log(LOG_INFO, 0,
		"Ignoring PIM_ASSERT from non-neighbor router %s",
		inet6_fmt(&src->sin6_addr));
	return (FALSE);
    }

    v = &uvifs[mifi];
    v->uv_in_pim6_assert++;
    if (uvifs[mifi].uv_flags &
	(VIFF_DOWN | VIFF_DISABLED | VIFF_NONBRS | MIFF_REGISTER))
	return (FALSE);		/* Shoudn't come on this interface */
    data_ptr = (u_int8 *) (pim_message + sizeof(struct pim));

    /* Get the group and source addresses */
    GET_EGADDR6(&egaddr, data_ptr);
    GET_EUADDR6(&eusaddr, data_ptr);

    /* Get the metric related info */
    GET_HOSTLONG(assert_preference, data_ptr);
    GET_HOSTLONG(assert_metric, data_ptr);
    assert_rptbit = assert_preference & PIM_ASSERT_RPT_BIT;

    source.sin6_addr  = eusaddr.unicast_addr;
    source.sin6_scope_id = inet6_uvif2scopeid(&source, v);

    group.sin6_addr = egaddr.mcast_addr;
    group.sin6_scope_id = inet6_uvif2scopeid(&group, v);

    /* Find the longest "active" entry, i.e. the one with a kernel mirror */
    if (assert_rptbit)
    {
	mrtentry_ptr = find_route(NULL, &group,
				  MRTF_WC | MRTF_PMBR, DONT_CREATE);
	if (mrtentry_ptr != (mrtentry_t *) NULL)
	    if (!(mrtentry_ptr->flags & MRTF_KERNEL_CACHE))
		if (mrtentry_ptr->flags & MRTF_WC)
		{
		    mrtentry_ptr =
			mrtentry_ptr->group->active_rp_grp->rp->rpentry->mrtlink;
		}
    }
    else
    {
	mrtentry_ptr = find_route(&source, &group,
				MRTF_SG | MRTF_WC | MRTF_PMBR, DONT_CREATE);
	if ((mrtentry_ptr != (mrtentry_t *) NULL))
	    if (!(mrtentry_ptr->flags & MRTF_KERNEL_CACHE))
	    {
		if (mrtentry_ptr->flags & MRTF_SG)
		{
		    mrtentry_ptr2 = mrtentry_ptr->group->grp_route;
		    if ((mrtentry_ptr2 != (mrtentry_t *) NULL)
			&& (mrtentry_ptr2->flags & MRTF_KERNEL_CACHE))
			mrtentry_ptr = mrtentry_ptr2;
		    else
			mrtentry_ptr = mrtentry_ptr->group->active_rp_grp->rp->rpentry->mrtlink;
		}
		else
		    if (mrtentry_ptr->flags & MRTF_WC)
			mrtentry_ptr = mrtentry_ptr->group->active_rp_grp->rp->rpentry->mrtlink;
	    }
    }
    if ((mrtentry_ptr == (mrtentry_t *) NULL)
	|| (!(mrtentry_ptr->flags & MRTF_KERNEL_CACHE)))
	/* No routing entry or not "active" entry. Ignore the assert */
	return (FALSE);

    /* Prepare the local preference and metric */
    if ((mrtentry_ptr->flags & MRTF_PMBR)
	|| ((mrtentry_ptr->flags & MRTF_SG)
	    && (!(mrtentry_ptr->flags & MRTF_RP))))
    {
	/* Either (S,G) (toward S) or (*,*,RP). */
	/* TODO: XXX: get the info from mrtentry, or source or from kernel ? */
	/*
	 * local_metric = mrtentry_ptr->source->metric; local_preference =
	 * mrtentry_ptr->source->preference;
	 */
	local_metric = mrtentry_ptr->metric;
	local_preference = mrtentry_ptr->preference;
    }
    else
    {
	/*
	 * Should be (*,G) or (S,G)RPbit entry. Get what we need from the RP
	 * info.
	 */
	/* TODO: get the info from mrtentry, RP-entry or kernel? */
	/*
	 * local_metric =
	 * mrtentry_ptr->group->active_rp_grp->rp->rpentry->metric;
	 * local_preference =
	 * mrtentry_ptr->group->active_rp_grp->rp->rpentry->preference;
	 */

	local_metric = mrtentry_ptr->metric;
	local_preference = mrtentry_ptr->preference;
    }

    local_rptbit = (mrtentry_ptr->flags & MRTF_RP);
    if (local_rptbit)
	/* Make the RPT bit the most significant one */
	local_preference |= PIM_ASSERT_RPT_BIT;


    if (IF_ISSET(mifi, &mrtentry_ptr->oifs))
    {
	/* The ASSERT has arrived on oif */

	/*
	 * TODO: XXX: here the processing order is different from the spec.
	 * The spec requires first eventually to create a routing entry (see
	 * 3.5.2.1(1) and then compare the metrics. Here we compare first the
	 * metrics with the existing longest match entry and if we lose then
	 * create a new entry and compare again. This saves us the
	 * unnecessary creating of a routing entry if we anyway are going to
	 * lose: for example the local (*,*,RP) vs the remote (*,*,RP) or
	 * (*,G)
	 */

	local_wins = compare_metrics(local_preference, local_metric,
				     &v->uv_linklocal->pa_addr, assert_preference,
				     assert_metric, src);

	if (local_wins == TRUE)
	{
	    /* TODO: verify the parameters */
	    send_pim6_assert(&source, &group, mifi, mrtentry_ptr);
	    return (TRUE);
	}

	/* Create a "better" routing entry and try again */

	if ((assert_rptbit) && (mrtentry_ptr->flags & MRTF_PMBR))
	{
	    /* The matching entry was (*,*,RP). Create (*,G) */
	    mrtentry_ptr2 = find_route(NULL, &group, MRTF_WC, CREATE);
	}
	else
	    if ((!assert_rptbit) &&
		(mrtentry_ptr->flags & (MRTF_WC | MRTF_PMBR)))
	    {
		/* create (S,G) */
		mrtentry_ptr2 = find_route(&source, &group, MRTF_SG, CREATE);
	    }
	    else
	    {
		/* We have no chance to win. Give up and prune the oif */
		mrtentry_ptr2 = (mrtentry_t *) NULL;
	    }

	if (mrtentry_ptr2 != (mrtentry_t *) NULL)
	{
	    mrtentry_ptr2->flags &= ~MRTF_NEW;

	    /*
	     * TODO: XXX: The spec doesn't say what entry timer value to use
	     * when the routing entry is created because of asserts.
	     */

	    SET_TIMER(mrtentry_ptr2->timer, pim_data_timeout);
	    if (mrtentry_ptr2->flags & MRTF_RP)
	    {
		/*
		 * Either (*,G) or (S,G)RPbit entry. Get what we need from
		 * the RP info.
		 */
		/* TODO: where to get the metric+preference from? */
		/*
		 * local_metric =
		 * mrtentry_ptr->group->active_rp_grp->rp->rpentry->metric;
		 * local_preference =
		 * mrtentry_ptr->group->active_rp_grp->rp->rpentry->preference
		 * ;
		 */
		local_metric = mrtentry_ptr->metric;
		local_preference = mrtentry_ptr->preference;
		local_preference |= PIM_ASSERT_RPT_BIT;
	    }
	    else
	    {
		/* (S,G) toward the source */
		/* TODO: where to get the metric from ? */
		/*
		 * local_metric = mrtentry_ptr->source->metric;
		 * local_preference = mrtentry_ptr->source->preference;
		 */
		local_metric = mrtentry_ptr->metric;
		local_preference = mrtentry_ptr->preference;
	    }

	    local_wins = compare_metrics(local_preference, local_metric,
					 &v->uv_linklocal->pa_addr, assert_preference,
					 assert_metric, src);

	    if (local_wins == TRUE)
	    {
		/* TODO: verify the parameters */
		send_pim6_assert(&source, &group, mifi, mrtentry_ptr);
		return (TRUE);
	    }
	    /* We lost, but have created the entry which has to be pruned */
	    mrtentry_ptr = mrtentry_ptr2;
	}

	/* Have to remove that outgoing vifi from mrtentry_ptr */
	IF_SET(mifi, &mrtentry_ptr->asserted_oifs);
	/* TODO: XXX: TIMER implem. dependency! */
	if (mrtentry_ptr->timer < pim_assert_timeout)
	    SET_TIMER(mrtentry_ptr->timer, pim_assert_timeout);
	/*
	 * TODO: XXX: check that the timer of all affected routing entries
	 * has been restarted.
	 */
	change_interfaces(mrtentry_ptr,
			  mrtentry_ptr->incoming,
			  &mrtentry_ptr->joined_oifs,
			  &mrtentry_ptr->pruned_oifs,
			  &mrtentry_ptr->leaves,
			  &mrtentry_ptr->asserted_oifs, 0);
	return (FALSE);		/* Doesn't matter the return value */
    }				/* End of assert received on oif */


    if (mrtentry_ptr->incoming == mifi)
    {
	/* Assert received on iif */
	if (assert_rptbit)
	{
	    if (!(mrtentry_ptr->flags & MRTF_RP))
		return (TRUE);	/* The locally used upstream router will win
				 * the assert, so don't change it. */
	}

	/*
	 * TODO: where to get the local metric and preference from? system
	 * call or mrtentry is fine?
	 */
	local_metric = mrtentry_ptr->metric;
	local_preference = mrtentry_ptr->preference;
	if (mrtentry_ptr->flags & MRTF_RP)
	    local_preference |= PIM_ASSERT_RPT_BIT;

	local_wins = compare_metrics(local_preference, local_metric,
				     &mrtentry_ptr->upstream->address,
				     assert_preference, assert_metric, src);

	if (local_wins == TRUE)
	    return (TRUE);	/* return whatever */

	/* The upstream must be changed to the winner */
	mrtentry_ptr->preference = assert_preference;
	mrtentry_ptr->metric = assert_metric;
	mrtentry_ptr->upstream = find_pim6_nbr(src);

	/* Check if the upstream router is different from the original one */
	if (mrtentry_ptr->flags & MRTF_PMBR)
	    original_upstream_router = mrtentry_ptr->source->upstream;
	else
	    if (mrtentry_ptr->flags & MRTF_RP)
		original_upstream_router =
		    mrtentry_ptr->group->active_rp_grp->rp->rpentry->upstream;
	    else
		original_upstream_router = mrtentry_ptr->source->upstream;
	if (mrtentry_ptr->upstream != original_upstream_router)
	{
	    mrtentry_ptr->flags |= MRTF_ASSERTED;
	    SET_TIMER(mrtentry_ptr->assert_timer, pim_assert_timeout);
	}
	else
	    mrtentry_ptr->flags &= ~MRTF_ASSERTED;
    }

    return (TRUE);
}


int
send_pim6_assert(source, group, mifi, mrtentry_ptr)
    struct sockaddr_in6	*source;
    struct sockaddr_in6 *group;
    mifi_t          mifi;
    mrtentry_t     *mrtentry_ptr;
{
    u_int8         *data_ptr;
    u_int8         *data_start_ptr;
    u_int32         local_preference;
    u_int32         local_metric;
    srcentry_t     *srcentry_ptr;

    /* Don't send assert if the outgoing interface a tunnel or register vif */
    if (uvifs[mifi].uv_flags & (MIFF_REGISTER | VIFF_TUNNEL))
	return (FALSE);

    data_ptr = (u_int8 *) (pim6_send_buf + sizeof(struct pim));
    data_start_ptr = data_ptr;
    PUT_EGADDR6(group->sin6_addr, SINGLE_GRP_MSK6LEN, 0, data_ptr);
    PUT_EUADDR6(source->sin6_addr, data_ptr);

    /*
     * TODO: XXX: where to get the metric from: srcentry_ptr or mrtentry_ptr
     * or from the kernel?
     */

    if (mrtentry_ptr->flags & MRTF_PMBR)
    {
	/* (*,*,RP) */
	srcentry_ptr = mrtentry_ptr->source;
	/*
	 * TODO: set_incoming(srcentry_ptr, PIM_IIF_RP);
	 */
    }
    else
	if (mrtentry_ptr->flags & MRTF_RP)
	{
	    /* (*,G) or (S,G)RPbit (iif toward RP) */
	    srcentry_ptr = mrtentry_ptr->group->active_rp_grp->rp->rpentry;
	    /*
	     * TODO: set_incoming(srcentry_ptr, PIM_IIF_RP);
	     */
	}
	else
	{
	    /* (S,G) toward S */
	    srcentry_ptr = mrtentry_ptr->source;
	    /*
	     * TODO: set_incoming(srcentry_ptr, PIM_IIF_SOURCE);
	     */
	}

    /*
     * TODO: check again! local_metric = srcentry_ptr->metric;
     * local_preference = srcentry_ptr->preference;
     */
    local_metric = mrtentry_ptr->metric;
    local_preference = mrtentry_ptr->preference;

    if (mrtentry_ptr->flags & MRTF_RP)
	local_preference |= PIM_ASSERT_RPT_BIT;
    PUT_HOSTLONG(local_preference, data_ptr);
    PUT_HOSTLONG(local_metric, data_ptr);

    send_pim6(pim6_send_buf, &uvifs[mifi].uv_linklocal->pa_addr,
          &allpim6routers_group, PIM_ASSERT,
          data_ptr - data_start_ptr);
    uvifs[mifi].uv_out_pim6_assert++;

    return (TRUE);
}


/* Return TRUE if the local win, otherwise FALSE */
static int
compare_metrics(local_preference, local_metric, local_address,
		remote_preference, remote_metric, remote_address)
    u_int32         		local_preference;
    u_int32         		local_metric;
    struct sockaddr_in6		*local_address;
    u_int32         		remote_preference;
    u_int32         		remote_metric;
    struct sockaddr_in6 	*remote_address;
{
    /* Now lets see who has a smaller gun (aka "asserts war") */
    /*
     * FYI, the smaller gun...err metric wins, but if the same caliber, then
     * the bigger network address wins. The order of threatment is:
     * preference, metric, address.
     */
    /*
     * The RPT bits are already included as the most significant bits of the
     * preferences.
     */
    if (remote_preference > local_preference)
	return TRUE;
    if (remote_preference < local_preference)
	return FALSE;
    if (remote_metric > local_metric)
	return TRUE;
    if (remote_metric < local_metric)
	return FALSE;
    if (inet6_greaterthan(local_address, remote_address))
       return TRUE;

    return FALSE;
}


/************************************************************************
 *                        PIM_BOOTSTRAP
 ************************************************************************/
#define	PIM6_BOOTSTRAP_MINLEN (PIM_MINLEN + PIM6_ENCODE_UNI_ADDR_LEN)

int
receive_pim6_bootstrap(src, dst, pim_message, datalen)
    struct sockaddr_in6		*src,
                    		*dst;
    char           		*pim_message;
    int             		datalen;
{
    u_int8         		*data_ptr;
    u_int8         		*max_data_ptr;
    u_int16         		new_bsr_fragment_tag;
    u_int8          		new_bsr_hash_masklen;
    u_int8          		new_bsr_priority;
    pim6_encod_uni_addr_t 	new_bsr_uni_addr;
    struct sockaddr_in6         new_bsr_address;
    struct rpfctl   		rpfc;
    pim_nbr_entry_t 		*n,
                   		*rpf_neighbor;
    struct sockaddr_in6         neighbor_addr;
    mifi_t          		mifi,
                    		incoming = NO_VIF;
    int             		min_datalen;
    pim6_encod_grp_addr_t 	curr_group_addr;
    pim6_encod_uni_addr_t 	curr_rp_addr;
    u_int8          		curr_rp_count;
    u_int8          		curr_frag_rp_count;
    u_int16         		reserved_short;
    u_int16         		curr_rp_holdtime;
    u_int8          		curr_rp_priority;
    u_int8          		reserved_byte;
    struct in6_addr    		curr_group_mask;
    grp_mask_t     		*grp_mask_ptr;
    grp_mask_t     		*grp_mask_next;
    rp_grp_entry_t 		*grp_rp_entry_ptr;
    rp_grp_entry_t 		*grp_rp_entry_next;
    struct sockaddr_in6		prefix_h,
				prefix_h2,
				group_,
				rpp_;
    int i;
    struct uvif 		*v;


    if ((mifi=find_vif_direct(src)) == NO_VIF)
    {
	/*
	 * Either a local vif or somehow received PIM_BOOTSTRAP from
	 * non-directly connected router. Ignore it.
	 */
	if (local_address(src) == NO_VIF)
	    log(LOG_INFO, 0,
		"Ignoring PIM_BOOTSTRAP from non-neighbor router %s",
		inet6_fmt(&src->sin6_addr));
	return (FALSE);
    }

    /* sanity check for the minimum length */
    if (datalen < PIM6_BOOTSTRAP_MINLEN) {
	    log(LOG_NOTICE, 0,
		"receive_pim6_bootstrap: Bootstrap message size(%u) is"
		" too short from %s",
		datalen, inet6_fmt(&src->sin6_addr));
	    return(FALSE);
    }

    v = &uvifs[mifi];
    v->uv_in_pim6_bootsrap++;
    data_ptr = (u_int8 *) (pim_message + sizeof(struct pim));

    /* Parse the PIM_BOOTSTRAP message */
    GET_HOSTSHORT(new_bsr_fragment_tag, data_ptr);
    GET_BYTE(new_bsr_hash_masklen, data_ptr);
    GET_BYTE(new_bsr_priority, data_ptr);
    GET_EUADDR6(&new_bsr_uni_addr, data_ptr);

    /*
     * BSR address must be a global unicast address.
     * [draft-ietf-pim-ipv6-01.txt sec 4.5]
     */
    if (IN6_IS_ADDR_MULTICAST(&new_bsr_uni_addr.unicast_addr) ||
	IN6_IS_ADDR_LINKLOCAL(&new_bsr_uni_addr.unicast_addr) ||
	IN6_IS_ADDR_SITELOCAL(&new_bsr_uni_addr.unicast_addr)) {
	    log(LOG_WARNING, 0,
		"receive_pim6_bootstrap: invalid BSR address: %s",
		inet6_fmt(&new_bsr_uni_addr.unicast_addr));
	    return(FALSE);
    }

    new_bsr_address.sin6_addr = new_bsr_uni_addr.unicast_addr;
    new_bsr_address.sin6_len = sizeof(new_bsr_address);
    new_bsr_address.sin6_family = AF_INET6;
    new_bsr_address.sin6_scope_id = inet6_uvif2scopeid(&new_bsr_address, v);

    if (local_address(&new_bsr_address) != NO_VIF)
    {
	IF_DEBUG(DEBUG_RPF | DEBUG_PIM_BOOTSTRAP)
	    log(LOG_DEBUG, 0,
		"receive_pim6_bootstrap: Bootstrap from myself(%s), ignored.",
		inet6_fmt(&new_bsr_address.sin6_addr));
	return (FALSE);		/* The new BSR is one of my local addresses */
    }

    /*
     * Compare the current BSR priority with the priority of the BSR included
     * in the message.
     */
    /*
     * TODO: if I am just starting and will become the BSR, I should accept
     * the message coming from the current BSR and get the current
     * Cand-RP-Set.
     */

    if ((curr_bsr_priority > new_bsr_priority) ||
	((curr_bsr_priority == new_bsr_priority)
	&& (inet6_greaterthan(&curr_bsr_address, &new_bsr_address))))
    {
	/* The message's BSR is less preferred than the current BSR */
	log(LOG_DEBUG, 0,
	    "receive_pim6_bootstrap: BSR(%s, prio=%d) is less preferred"
	    " than the current BSR(%s, prio=%d)",
	    inet6_fmt(&new_bsr_address.sin6_addr), new_bsr_priority,
	    inet6_fmt(&curr_bsr_address.sin6_addr), curr_bsr_priority);
	return (FALSE);		/* Ignore the received BSR message */
    }

    /* Check the iif, if this was PIM-ROUTERS multicast */
    if (IN6_ARE_ADDR_EQUAL(&dst->sin6_addr, &allpim6routers_group.sin6_addr))
    {
	k_req_incoming(&new_bsr_address, &rpfc);
	if ((rpfc.iif == NO_VIF) ||
	    IN6_IS_ADDR_UNSPECIFIED(&rpfc.rpfneighbor.sin6_addr))
	{
	    /* coudn't find a route to the BSR */
	    log(LOG_NOTICE, 0,
		"receive_pim6_bootstrap: can't find a route to the BSR(%s)",
		inet6_fmt(&new_bsr_address.sin6_addr));
	    return (FALSE);
	}

	neighbor_addr = *src;
	incoming = rpfc.iif;

	if (uvifs[incoming].uv_flags &
	    (VIFF_DISABLED | VIFF_DOWN | MIFF_REGISTER))
	{
	  log(LOG_NOTICE, 0,
	      "receive_pim6_bootstrap: Bootstrap from an invalid interface(%s)",
	      uvifs[incoming].uv_name);
	    return (FALSE);	/* Shoudn't arrive on that interface */
	}

	/* Find the upstream router */

	for (n = uvifs[incoming].uv_pim_neighbors; n != NULL; n = n->next)
	{
	    if (inet6_lessthan(&neighbor_addr, &n->address))
		continue;
	    if (inet6_equal(&neighbor_addr, &n->address))
	    {
		rpf_neighbor = n;
		break;
	    }
	    log(LOG_NOTICE, 0,
		"receive_pim6_bootstrap: Bootstrap from an unrecognized "
		"neighbor(%s) on %s",
		inet6_fmt(&neighbor_addr.sin6_addr), uvifs[incoming].uv_name);
	    return (FALSE);	/* No neighbor toward BSR found */
	}

	/* redundant checks? */
	if ((n == (pim_nbr_entry_t *) NULL ))
	{
	    return (FALSE);	/* Sender of this message is not the RPF*/
	}
				 			/* neighbor */
	if(!(inet6_equal(&n->address, src)))
	{
		return (FALSE);
	}
    }
    else
    {
	if (local_address(dst) == NO_VIF)
	    /*
	     * TODO: XXX: this situation should be handled earlier: The
	     * destination is neither ALL_PIM_ROUTERS nor me
	     */
	    log(LOG_NOTICE, 0,
		"receive_pim6_bootstrap: Bootstrap with an invalid dst(%s)",
		inet6_fmt(&dst->sin6_addr));
	    return (FALSE);

	/* Probably unicasted from the current DR */
	if (cand_rp_list != (cand_rp_t *) NULL)
	{
	    /*
	     * Hmmm, I do have a Cand-RP-list, but some neighbor has a
	     * different opinion and is unicasting it to me. Ignore this guy.
	     */
	    log(LOG_INFO, 0,
		"receive_pim6_bootstrap: Bootstrap received but we already "
		"have RPs. ignored.");
	    return (FALSE);
	}
	for (mifi = 0; mifi < numvifs; mifi++)
	{
	    if (uvifs[mifi].uv_flags & (VIFF_DISABLED | VIFF_DOWN |
					MIFF_REGISTER))
		continue;
	    if (inet6_equal(&uvifs[mifi].uv_linklocal->pa_addr,dst))
	    {
		incoming = mifi;
		break;
	    }
	}
	if (incoming == NO_VIF)
	{
	    /* Cannot find the receiving iif toward that DR */
	    IF_DEBUG(DEBUG_RPF | DEBUG_PIM_BOOTSTRAP)
		log(LOG_DEBUG, 0,
		    "Unicast boostrap message from %s to %s ignored: "
		    "cannot find iif",
		    inet6_fmt(&src->sin6_addr), inet6_fmt(&dst->sin6_addr));
	    return (FALSE);
	}
	/*
	 * TODO: check the sender is directly connected and I am really the
	 * DR.
	 */
    }

    if (cand_rp_flag == TRUE)
    {
	/* If change in the BSR address, send immediately Cand-RP-Adv */
	/* TODO: use some random delay? */

	if (!inet6_equal(&new_bsr_address , &curr_bsr_address))
	{
	    send_pim6_cand_rp_adv();
	    SET_TIMER(pim_cand_rp_adv_timer, my_cand_rp_adv_period);
	}
    }

    /* Forward the BSR Message first and then update the RP-set list */
    /* XXX: should we do sanity checks before forwarding?? */
    /* TODO: if the message was unicasted to me, resend? */

    for (mifi = 0; mifi < numvifs; mifi++)
    {
	if (mifi == incoming)
	    continue;
	if (uvifs[mifi].uv_flags & (VIFF_DISABLED | VIFF_DOWN |
				    MIFF_REGISTER | VIFF_TUNNEL | VIFF_NONBRS))
	    continue;

	bcopy(pim_message, (char *)(pim6_send_buf), datalen);

	send_pim6(pim6_send_buf, &uvifs[mifi].uv_linklocal->pa_addr,
		  &allpim6routers_group, PIM_BOOTSTRAP,
		  datalen - sizeof(struct pim));
    }

    max_data_ptr = (u_int8 *) pim_message + datalen;

    /*
     * TODO: XXX: this 24 is HARDCODING!!! Do a bunch of definitions and make
     * it stylish!
     * 24 = Encoded-Group Address(20) + RP-cound(1) + Frag-RP(1) + Reserved(2)
     */
    min_datalen = 24;

    if ((new_bsr_fragment_tag != curr_bsr_fragment_tag) ||
	(inet6_equal(&new_bsr_address, &curr_bsr_address)))
    {
	/* Throw away the old segment */
	delete_rp_list(&segmented_cand_rp_list, &segmented_grp_mask_list);
    }

    curr_bsr_address = new_bsr_address;
    curr_bsr_priority = new_bsr_priority;
    curr_bsr_fragment_tag = new_bsr_fragment_tag;
    MASKLEN_TO_MASK6(new_bsr_hash_masklen, curr_bsr_hash_mask);
    SET_TIMER(pim_bootstrap_timer, PIM_BOOTSTRAP_TIMEOUT);

    while (data_ptr + min_datalen <= max_data_ptr)
    {
	GET_EGADDR6(&curr_group_addr, data_ptr);
	GET_BYTE(curr_rp_count, data_ptr);
	GET_BYTE(curr_frag_rp_count, data_ptr);
	GET_HOSTSHORT(reserved_short, data_ptr);
	MASKLEN_TO_MASK6(curr_group_addr.masklen, curr_group_mask);
	if (curr_rp_count == 0)
	{
	    group_.sin6_addr = curr_group_addr.mcast_addr;
	    delete_grp_mask(&cand_rp_list, &grp_mask_list,
			    &group_, curr_group_mask);
	    continue;
	}
	if (curr_rp_count == curr_frag_rp_count)
    	{
            /* Add all RPs */
	    while (curr_frag_rp_count--)
	    {
		/*
		 * Sanity for the data length; the data packet must contain
		 * Encoded-Unicast-RP-Address(18) + RP-Holdtime(2) +
		 * RP-Priority(1) + Reserved(1).
		 */
		if (data_ptr + PIM6_ENCODE_UNI_ADDR_LEN + sizeof(u_int32_t)
		    > max_data_ptr) {
		    log(LOG_NOTICE, 0,
			"receive_pim6_bootstrap: Bootstrap from %s on %s "
			"does not have enough length to contatin RP information",
			inet6_fmt(&src->sin6_addr), v->uv_name);

		    /*
		     * Ignore the rest of the message.
		     * XXX: should we discard the entire message?
		     */
		    goto garbage_collect;
		}

		GET_EUADDR6(&curr_rp_addr, data_ptr);
		GET_HOSTSHORT(curr_rp_holdtime, data_ptr);
		GET_BYTE(curr_rp_priority, data_ptr);
		GET_BYTE(reserved_byte, data_ptr);
		MASKLEN_TO_MASK6(curr_group_addr.masklen, curr_group_mask);
		rpp_.sin6_addr = curr_rp_addr.unicast_addr;
    		rpp_.sin6_len = sizeof(rpp_);
    		rpp_.sin6_family = AF_INET6;
		/*
		 * The cand_rp address scope should be global.
		 * XXX: however, is a site-local RP sometimes useful?
		 *      we currently discard such RP...
		 */
		if (IN6_IS_ADDR_LINKLOCAL(&rpp_.sin6_addr) ||
		    IN6_IS_ADDR_SITELOCAL(&rpp_.sin6_addr)) {
			log(LOG_WARNING, 0,
			    "receive_pim6_bootstrap: invalid RP address: %s",
			    inet6_fmt(&rpp_.sin6_addr));
			continue;
		}
    		rpp_.sin6_scope_id = 0;
		group_.sin6_addr = curr_group_addr.mcast_addr;
		group_.sin6_len = sizeof(group_);
		group_.sin6_family = AF_INET6;
		group_.sin6_scope_id = inet6_uvif2scopeid(&group_,v);

		add_rp_grp_entry(&cand_rp_list, &grp_mask_list,
				 &rpp_, curr_rp_priority,
				 curr_rp_holdtime, &group_,
				 curr_group_mask,
				 curr_bsr_hash_mask,
				 curr_bsr_fragment_tag);
	    }
	    continue;
	}
	/*
	 * This is a partial list of the RPs for this group prefix. Save
	 * until all segments arrive.
	 */

	for (i = 0; i < sizeof(struct in6_addr); i++) {
	    prefix_h.sin6_addr.s6_addr[i] =
		curr_group_addr.mcast_addr.s6_addr[i]
		    & curr_group_mask.s6_addr[i];
	}

	for (grp_mask_ptr = segmented_grp_mask_list;
	     grp_mask_ptr != (grp_mask_t *) NULL;
	     grp_mask_ptr = grp_mask_ptr->next)
	{
	    for (i = 0; i < sizeof(struct in6_addr); i++) {
		prefix_h2.sin6_addr.s6_addr[i] =
		    grp_mask_ptr->group_addr.sin6_addr.s6_addr[i]
			& grp_mask_ptr->group_mask.s6_addr[i];
	    }

	    if (inet6_lessthan(&prefix_h2, &prefix_h))
		continue;
	    else
		break;
	}
	if ((grp_mask_ptr != (grp_mask_t *) NULL)
	    && (IN6_ARE_ADDR_EQUAL(&grp_mask_ptr->group_addr.sin6_addr,
				   &curr_group_addr.mcast_addr))
	    && (IN6_ARE_ADDR_EQUAL(&grp_mask_ptr->group_mask, &curr_group_mask))
	    && (grp_mask_ptr->group_rp_number + curr_frag_rp_count
		== curr_rp_count))
	{
	    /* All missing PRs have arrived. Add all RP entries */
	    while (curr_frag_rp_count--)
	    {
		GET_EUADDR6(&curr_rp_addr, data_ptr);
		GET_HOSTSHORT(curr_rp_holdtime, data_ptr);
		GET_BYTE(curr_rp_priority, data_ptr);
		GET_BYTE(reserved_byte, data_ptr);
		MASKLEN_TO_MASK6(curr_group_addr.masklen, curr_group_mask);
		rpp_.sin6_addr = curr_rp_addr.unicast_addr;
		rpp_.sin6_scope_id=0;
		group_.sin6_addr = curr_group_addr.mcast_addr;
		group_.sin6_scope_id = inet6_uvif2scopeid(&group_,v);
		add_rp_grp_entry(&cand_rp_list,
				 &grp_mask_list,
				 &rpp_,
				 curr_rp_priority,
				 curr_rp_holdtime,
				 &group_,
				 curr_group_mask,
				 curr_bsr_hash_mask,
				 curr_bsr_fragment_tag);
	    }
	    /* Add the rest from the previously saved segments */
	    for (grp_rp_entry_ptr = grp_mask_ptr->grp_rp_next;
		 grp_rp_entry_ptr != (rp_grp_entry_t *) NULL;
		 grp_rp_entry_ptr = grp_rp_entry_ptr->grp_rp_next)
	    {
		group_.sin6_addr = curr_group_addr.mcast_addr;
		group_.sin6_scope_id = inet6_uvif2scopeid(&group_,v);
		add_rp_grp_entry(&cand_rp_list,
				 &grp_mask_list,
				 &grp_rp_entry_ptr->rp->rpentry->address,
				 grp_rp_entry_ptr->priority,
				 grp_rp_entry_ptr->holdtime,
				 &group_,
				 curr_group_mask,
				 curr_bsr_hash_mask,
				 curr_bsr_fragment_tag);
	    }
	    group_.sin6_addr = curr_group_addr.mcast_addr;
	    group_.sin6_scope_id = inet6_uvif2scopeid(&group_,v);
		delete_grp_mask(&segmented_cand_rp_list,
			    &segmented_grp_mask_list,
			    &group_,
			    curr_group_mask);
	}
	else
	{
	    /* Add the partially received RP-list to the group of pending RPs */
	    while (curr_frag_rp_count--)
	    {
		GET_EUADDR6(&curr_rp_addr, data_ptr);
		GET_HOSTSHORT(curr_rp_holdtime, data_ptr);
		GET_BYTE(curr_rp_priority, data_ptr);
		GET_BYTE(reserved_byte, data_ptr);
		MASKLEN_TO_MASK6(curr_group_addr.masklen, curr_group_mask);
		rpp_.sin6_addr = curr_rp_addr.unicast_addr;
		group_.sin6_addr = curr_group_addr.mcast_addr;
		group_.sin6_scope_id = inet6_uvif2scopeid(&group_,v);
		add_rp_grp_entry(&segmented_cand_rp_list,
				 &segmented_grp_mask_list,
				 &rpp_,
				 curr_rp_priority,
				 curr_rp_holdtime,
				 &group_,
				 curr_group_mask,
				 curr_bsr_hash_mask,
				 curr_bsr_fragment_tag);
	    }
	}
    }


 garbage_collect:
    /*
     * Garbage collection. Check all group prefixes and if the fragment_tag
     * for a group_prefix is the same as curr_bsr_fragment_tag, then remove
     * all RPs for this group_prefix which have different fragment tag.
     */

    for (grp_mask_ptr = grp_mask_list;
	 grp_mask_ptr != (grp_mask_t *) NULL;
	 grp_mask_ptr = grp_mask_next)
    {
	grp_mask_next = grp_mask_ptr->next;
	if (grp_mask_ptr->fragment_tag == curr_bsr_fragment_tag)
	{
	    for (grp_rp_entry_ptr = grp_mask_ptr->grp_rp_next;
		 grp_rp_entry_ptr != (rp_grp_entry_t *) NULL;
		 grp_rp_entry_ptr = grp_rp_entry_next)
	    {
		grp_rp_entry_next = grp_rp_entry_ptr->grp_rp_next;
		if (grp_rp_entry_ptr->fragment_tag != curr_bsr_fragment_tag)
		    delete_rp_grp_entry(&cand_rp_list, &grp_mask_list,
					grp_rp_entry_ptr);
	    }
	}
    }

    /* Cleanup also the list used by incompleted segments */

    for (grp_mask_ptr = segmented_grp_mask_list;
	 grp_mask_ptr != (grp_mask_t *) NULL;
	 grp_mask_ptr = grp_mask_next)
    {
	grp_mask_next = grp_mask_ptr->next;
	if (grp_mask_ptr->fragment_tag == curr_bsr_fragment_tag)
	{
	    for (grp_rp_entry_ptr = grp_mask_ptr->grp_rp_next;
		 grp_rp_entry_ptr != (rp_grp_entry_t *) NULL;
		 grp_rp_entry_ptr = grp_rp_entry_next)
	    {
		grp_rp_entry_next = grp_rp_entry_ptr->grp_rp_next;
		if (grp_rp_entry_ptr->fragment_tag != curr_bsr_fragment_tag)
		    delete_rp_grp_entry(&segmented_cand_rp_list,
					&segmented_grp_mask_list,
					grp_rp_entry_ptr);
	    }
	}
    }

    return (TRUE);
}

void
send_pim6_bootstrap()
{
    int             datalen;
    mifi_t          mifi;

    if ((datalen = create_pim6_bootstrap_message(pim6_send_buf)))
    {
	for (mifi = 0; mifi < numvifs; mifi++)
	{
	    if (uvifs[mifi].uv_flags & (VIFF_DISABLED | VIFF_DOWN |
					MIFF_REGISTER | VIFF_TUNNEL))
		continue;

   	     send_pim6(pim6_send_buf, &uvifs[mifi].uv_linklocal->pa_addr,
          	       &allpim6routers_group, PIM_BOOTSTRAP, datalen);
	     uvifs[mifi].uv_out_pim6_bootsrap++;
	}
    }
}

/************************************************************************
 *                        PIM_CAND_RP_ADV
 ************************************************************************/
/*
 * minimum length of a cand. RP adv. message;
 * length of PIM header + prefix-cnt(1) + priority(1) + holdtime(2) +
 *                        encoded unicast RP addr(18)
  */
#define	PIM6_CAND_RP_ADV_MINLEN (PIM_MINLEN + PIM6_ENCODE_UNI_ADDR_LEN)

/*
 * If I am the Bootstrap router, process the advertisement, otherwise ignore
 * it.
 */
int
receive_pim6_cand_rp_adv(src, dst, pim_message, datalen)
    struct sockaddr_in6         *src,
                    			*dst;
    char           		*pim_message;
    register int    		datalen;
{
    u_int8          		prefix_cnt;
    u_int8          		priority;
    u_int16         		holdtime;
    pim6_encod_uni_addr_t 	cand_rp_addr;
    pim6_encod_grp_addr_t 	encod_grp_addr;
    u_int8         		*data_ptr;
    struct in6_addr         	grp_mask;
    struct sockaddr_in6		group_, rpp_;

    pim6dstat.in_pim6_cand_rp++;

    /* if I am not the bootstrap RP, then do not accept the message */
    if ((cand_bsr_flag != FALSE) &&
	!inet6_equal(&curr_bsr_address, &my_bsr_address))
    {
	log(LOG_NOTICE, 0,
	    "receive_pim6_cand_rp_adv: receive cand_RP from %s "
	    "but I'm not the BSR",
	    inet6_fmt(&src->sin6_addr));
	return (FALSE);
    }

    /* sanity check for the minimum length */
    if (datalen < PIM6_CAND_RP_ADV_MINLEN) {
	    log(LOG_NOTICE, 0,
		"receive_pim6_cand_rp_adv: cand_RP message size(%u) is"
		" too short from %s",
		datalen, inet6_fmt(&src->sin6_addr));
	    return(FALSE);
    }
    datalen -= PIM6_CAND_RP_ADV_MINLEN;

    data_ptr = (u_int8 *) (pim_message + sizeof(struct pim));
    /* Parse the CAND_RP_ADV message */
    GET_BYTE(prefix_cnt, data_ptr);
    GET_BYTE(priority, data_ptr);
    GET_HOSTSHORT(holdtime, data_ptr);
    GET_EUADDR6(&cand_rp_addr, data_ptr);

    /*
     * The RP Address field is set to the globally reachable IPv6 address
     * [draft-ietf-pim-ipv6].
     */
    if (IN6_IS_ADDR_LINKLOCAL(&cand_rp_addr.unicast_addr)) {
	    /* XXX: prohibit a site-local address as well? */
	    log(LOG_WARNING, 0,
		"receive_pim6_cand_rp_adv: non global address(%s) as RP",
		inet6_fmt(&cand_rp_addr.unicast_addr));
	    return(FALSE);
    }

    memset(&rpp_, 0, sizeof(rpp_));
    if (prefix_cnt == 0)
    {
	/* The default ff:: and masklen of 8 */
	MASKLEN_TO_MASK6(ALL_MCAST_GROUPS_LENGTH, grp_mask);
	rpp_.sin6_addr = cand_rp_addr.unicast_addr;
	/*
	 * note that we don't have to take care of scope id, since
	 * the address should be global(see above).
	 */
	add_rp_grp_entry(&cand_rp_list, &grp_mask_list,
			 &rpp_, priority, holdtime,
			 &sockaddr6_d, grp_mask,
			 my_bsr_hash_mask,
			 curr_bsr_fragment_tag);
	return (TRUE);
    }
    while (prefix_cnt--)
    {
	    /*
	     * Sanity check for the message length.
	     * XXX: do we have to do the check at an earlier stage and
	     *      discard the whole message (instead of adopting a part of it)
	     *      if it's bogus?
	     */
	    if (datalen < PIM6_ENCODE_GRP_ADDR_LEN) {
		    log(LOG_NOTICE, 0,
			"receive_pim6_cand_rp_adv: cand_RP message from %s is"
			" too short to contain enough groups",
			inet6_fmt(&src->sin6_addr));
		    return(FALSE);
	    }
	    datalen -= PIM6_ENCODE_GRP_ADDR_LEN;

	    GET_EGADDR6(&encod_grp_addr, data_ptr);
	    MASKLEN_TO_MASK6(encod_grp_addr.masklen, grp_mask);
	    group_.sin6_addr = encod_grp_addr.mcast_addr;
	    group_.sin6_scope_id = 0; /* XXX: what if for scoped multicast addr? */
	    rpp_.sin6_addr = cand_rp_addr.unicast_addr;
	    /* see above note on scope id */

	    add_rp_grp_entry(&cand_rp_list, &grp_mask_list,
			     &rpp_, priority, holdtime,
			     &group_, grp_mask,
			     my_bsr_hash_mask,
			     curr_bsr_fragment_tag);
    }

    return (TRUE);
}

int
send_pim6_cand_rp_adv()
{
    u_int8          		prefix_cnt;
    struct in6_addr  		grp_mask;
    pim6_encod_grp_addr_t 	encod_grp_addr;
    u_int8         		*data_ptr;
    struct sockaddr_in6		group_;

    if (!inet6_valid_host(&curr_bsr_address))
	return (FALSE);		/* No BSR yet */

    if( inet6_equal(&curr_bsr_address, &my_bsr_address))
    {
	/* I am the BSR and have to include my own group_prefix stuff */
	prefix_cnt = *cand_rp_adv_message.prefix_cnt_ptr;
	if (prefix_cnt == 0)
	{
	    /* The default ff00:: and masklen of 8 */
	    MASKLEN_TO_MASK6(ALL_MCAST_GROUPS_LENGTH, grp_mask);
	    add_rp_grp_entry(&cand_rp_list, &grp_mask_list,
			     &my_cand_rp_address, my_cand_rp_priority,
			     my_cand_rp_holdtime,
			     &sockaddr6_d,
			     grp_mask,
			     my_bsr_hash_mask,
			     curr_bsr_fragment_tag);
	    return (TRUE);
	}
	/* TODO: hardcoding!! */
	/* 18 = sizeof(pim6_encod_uni_addr_t) without padding */
	data_ptr = cand_rp_adv_message.buffer + (4 + 18);

	while (prefix_cnt--)
	{
	    GET_EGADDR6(&encod_grp_addr, data_ptr);
	    MASKLEN_TO_MASK6(encod_grp_addr.masklen, grp_mask);
	    group_.sin6_addr = encod_grp_addr.mcast_addr;
	    group_.sin6_scope_id = 0;			/*XXX */
		add_rp_grp_entry(&cand_rp_list,
			     &grp_mask_list,
			     &my_cand_rp_address, my_cand_rp_priority,
			     my_cand_rp_holdtime,
			     &group_, grp_mask,
			     my_bsr_hash_mask,
			     curr_bsr_fragment_tag);
	}
	return (TRUE);
    }

    data_ptr = (u_int8 *) (pim6_send_buf + sizeof(struct pim));

    bcopy((char *)cand_rp_adv_message.buffer, (char *) data_ptr,
	  cand_rp_adv_message.message_size);

    send_pim6(pim6_send_buf, &my_cand_rp_address, &curr_bsr_address ,
            PIM_CAND_RP_ADV, cand_rp_adv_message.message_size);
    pim6dstat.out_pim6_cand_rp++;

    return TRUE;
}