[mirror_frr.git] / pimd / pim_hello.c

/*
  PIM for Quagga
  Copyright (C) 2008  Everton da Silva Marques

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with this program; see the file COPYING; if not, write to the
  Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
  MA 02110-1301 USA
*/

#include <zebra.h>

#include "log.h"
#include "if.h"

#include "pimd.h"
#include "pim_pim.h"
#include "pim_str.h"
#include "pim_tlv.h"
#include "pim_util.h"
#include "pim_hello.h"
#include "pim_iface.h"
#include "pim_neighbor.h"
#include "pim_upstream.h"

static void on_trace(const char *label,
		     struct interface *ifp, struct in_addr src)
{
  if (PIM_DEBUG_PIM_TRACE) {
    char src_str[100];
    pim_inet4_dump("<src?>", src, src_str, sizeof(src_str));
    zlog_debug("%s: from %s on %s",
	       label, src_str, ifp->name);
  }
}

static void tlv_trace_bool(const char *label, const char *tlv_name,
			   const char *ifname, struct in_addr src_addr,
			   int isset, int value)
{
  if (isset) {
    char src_str[100];
    pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
    zlog_debug("%s: PIM hello option from %s on interface %s: %s=%d",
	       label, 
	       src_str, ifname,
	       tlv_name, value);
  }
}

static void tlv_trace_uint16(const char *label, const char *tlv_name,
			     const char *ifname, struct in_addr src_addr,
			     int isset, uint16_t value)
{
  if (isset) {
    char src_str[100];
    pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
    zlog_debug("%s: PIM hello option from %s on interface %s: %s=%u",
	       label, 
	       src_str, ifname,
	       tlv_name, value);
  }
}

static void tlv_trace_uint32(const char *label, const char *tlv_name,
			     const char *ifname, struct in_addr src_addr,
			     int isset, uint32_t value)
{
  if (isset) {
    char src_str[100];
    pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
    zlog_debug("%s: PIM hello option from %s on interface %s: %s=%u",
	       label, 
	       src_str, ifname,
	       tlv_name, value);
  }
}

static void tlv_trace_uint32_hex(const char *label, const char *tlv_name,
				 const char *ifname, struct in_addr src_addr,
				 int isset, uint32_t value)
{
  if (isset) {
    char src_str[100];
    pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
    zlog_debug("%s: PIM hello option from %s on interface %s: %s=%08x",
	       label, 
	       src_str, ifname,
	       tlv_name, value);
  }
}

#if 0
static void tlv_trace(const char *label, const char *tlv_name,
		      const char *ifname, struct in_addr src_addr,
		      int isset)
{
  if (isset) {
    char src_str[100];
    pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
    zlog_debug("%s: PIM hello option from %s on interface %s: %s",
	       label, 
	       src_str, ifname,
	       tlv_name);
  }
}
#endif

static void tlv_trace_list(const char *label, const char *tlv_name,
			   const char *ifname, struct in_addr src_addr,
			   int isset, struct list *addr_list)
{
  if (isset) {
    char src_str[100];
    pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
    zlog_debug("%s: PIM hello option from %s on interface %s: %s size=%d list=%p",
	       label, 
	       src_str, ifname,
	       tlv_name,
	       addr_list ? ((int) listcount(addr_list)) : -1,
	       (void *) addr_list);
  }
}

#define FREE_ADDR_LIST \
  if (hello_option_addr_list) { \
    list_delete(hello_option_addr_list); \
  }

#define FREE_ADDR_LIST_THEN_RETURN(code) \
{ \
  FREE_ADDR_LIST \
  return (code); \
}

int pim_hello_recv(struct interface *ifp,
		   struct in_addr src_addr,
		   uint8_t *tlv_buf, int tlv_buf_size)
{
  struct pim_interface *pim_ifp;
  struct pim_neighbor *neigh;
  uint8_t *tlv_curr;
  uint8_t *tlv_pastend;
  pim_hello_options hello_options = 0; /* bit array recording options found */
  uint16_t hello_option_holdtime = 0;
  uint16_t hello_option_propagation_delay = 0;
  uint16_t hello_option_override_interval = 0;
  uint32_t hello_option_dr_priority = 0;
  uint32_t hello_option_generation_id = 0;
  struct list *hello_option_addr_list = 0;

  if (PIM_DEBUG_PIM_HELLO)
    on_trace(__PRETTY_FUNCTION__, ifp, src_addr);

  pim_ifp = ifp->info;
  zassert(pim_ifp);

  ++pim_ifp->pim_ifstat_hello_recv;

  /*
    Parse PIM hello TLVs
   */
  zassert(tlv_buf_size >= 0);
  tlv_curr = tlv_buf;
  tlv_pastend = tlv_buf + tlv_buf_size;

  while (tlv_curr < tlv_pastend) {
    uint16_t option_type; 
    uint16_t option_len;
    int remain = tlv_pastend - tlv_curr;

    if (remain < PIM_TLV_MIN_SIZE) {
      if (PIM_DEBUG_PIM_HELLO) {
	char src_str[100];
	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
	zlog_debug("%s: short PIM hello TLV size=%d < min=%d from %s on interface %s",
		   __PRETTY_FUNCTION__,
		   remain, PIM_TLV_MIN_SIZE,
		   src_str, ifp->name);
      }
      FREE_ADDR_LIST_THEN_RETURN(-1);
    }

    option_type = PIM_TLV_GET_TYPE(tlv_curr);
    tlv_curr += PIM_TLV_TYPE_SIZE;
    option_len = PIM_TLV_GET_LENGTH(tlv_curr);
    tlv_curr += PIM_TLV_LENGTH_SIZE;

    if ((tlv_curr + option_len) > tlv_pastend) {
      if (PIM_DEBUG_PIM_HELLO) {
	char src_str[100];
	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
	zlog_debug("%s: long PIM hello TLV type=%d length=%d > left=%td from %s on interface %s",
		   __PRETTY_FUNCTION__,
		   option_type, option_len, tlv_pastend - tlv_curr,
		   src_str, ifp->name);
      }
      FREE_ADDR_LIST_THEN_RETURN(-2);
    }

    if (PIM_DEBUG_PIM_HELLO) {
      char src_str[100];
      pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
      zlog_debug("%s: parse left_size=%d: PIM hello TLV type=%d length=%d from %s on %s",
		 __PRETTY_FUNCTION__,
		 remain,
		 option_type, option_len,
		 src_str, ifp->name);
    }

    switch (option_type) {
    case PIM_MSG_OPTION_TYPE_HOLDTIME:
      if (pim_tlv_parse_holdtime(ifp->name, src_addr,
				 &hello_options,
				 &hello_option_holdtime,
				 option_len,
				 tlv_curr)) {
	FREE_ADDR_LIST_THEN_RETURN(-3);
      }
      break;
    case PIM_MSG_OPTION_TYPE_LAN_PRUNE_DELAY:
      if (pim_tlv_parse_lan_prune_delay(ifp->name, src_addr,
					&hello_options,
					&hello_option_propagation_delay,
					&hello_option_override_interval,
					option_len,
					tlv_curr)) {
	FREE_ADDR_LIST_THEN_RETURN(-4);
      }
      break;
    case PIM_MSG_OPTION_TYPE_DR_PRIORITY:
      if (pim_tlv_parse_dr_priority(ifp->name, src_addr,
				    &hello_options,
				    &hello_option_dr_priority,
				    option_len,
				    tlv_curr)) {
	FREE_ADDR_LIST_THEN_RETURN(-5);
      }
      break;
    case PIM_MSG_OPTION_TYPE_GENERATION_ID:
      if (pim_tlv_parse_generation_id(ifp->name, src_addr,
				      &hello_options,
				      &hello_option_generation_id,
				      option_len,
				      tlv_curr)) {
	FREE_ADDR_LIST_THEN_RETURN(-6);
      }
      break;
    case PIM_MSG_OPTION_TYPE_ADDRESS_LIST:
      if (pim_tlv_parse_addr_list(ifp->name, src_addr,
				  &hello_options,
				  &hello_option_addr_list,
				  option_len,
				  tlv_curr)) {
	return -7;
      }
      break;
    case PIM_MSG_OPTION_TYPE_DM_STATE_REFRESH:
      if (PIM_DEBUG_PIM_HELLO) {
	char src_str[100];
	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
	zlog_debug("%s: ignoring PIM hello dense-mode state refresh TLV option type=%d length=%d from %s on interface %s",
		   __PRETTY_FUNCTION__,
		   option_type, option_len,
		   src_str, ifp->name);
      }
      break;
    default:
      if (PIM_DEBUG_PIM_HELLO) {
	char src_str[100];
	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
	zlog_debug("%s: ignoring unknown PIM hello TLV type=%d length=%d from %s on interface %s",
		   __PRETTY_FUNCTION__,
		   option_type, option_len,
		   src_str, ifp->name);
      }
    }

    tlv_curr += option_len;
  }

  /*
    Check received PIM hello options
  */

  if (PIM_DEBUG_PIM_HELLO) {
    tlv_trace_uint16(__PRETTY_FUNCTION__, "holdtime",
		     ifp->name, src_addr,
		     PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_HOLDTIME),
		     hello_option_holdtime);
    tlv_trace_uint16(__PRETTY_FUNCTION__, "propagation_delay",
		     ifp->name, src_addr,
		     PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_LAN_PRUNE_DELAY),
		     hello_option_propagation_delay);
    tlv_trace_uint16(__PRETTY_FUNCTION__, "override_interval",
		     ifp->name, src_addr,
		     PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_LAN_PRUNE_DELAY),
		     hello_option_override_interval);
    tlv_trace_bool(__PRETTY_FUNCTION__, "can_disable_join_suppression",
		   ifp->name, src_addr,
		   PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_LAN_PRUNE_DELAY),
		   PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_CAN_DISABLE_JOIN_SUPPRESSION));
    tlv_trace_uint32(__PRETTY_FUNCTION__, "dr_priority",
		     ifp->name, src_addr,
		     PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_DR_PRIORITY),
		     hello_option_dr_priority);
    tlv_trace_uint32_hex(__PRETTY_FUNCTION__, "generation_id",
			 ifp->name, src_addr,
			 PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_GENERATION_ID),
			 hello_option_generation_id);
    tlv_trace_list(__PRETTY_FUNCTION__, "address_list",
		   ifp->name, src_addr,
		   PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_ADDRESS_LIST),
		   hello_option_addr_list);
  }

  if (!PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_HOLDTIME)) {
    if (PIM_DEBUG_PIM_HELLO) {
      char src_str[100];
      pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
      zlog_debug("%s: PIM hello missing holdtime from %s on interface %s",
		__PRETTY_FUNCTION__,
		src_str, ifp->name);
    }
  }

  /*
    New neighbor?
  */

  neigh = pim_neighbor_find(ifp, src_addr);
  if (!neigh) {
    /* Add as new neighbor */
    
    neigh = pim_neighbor_add(ifp, src_addr,
			     hello_options,
			     hello_option_holdtime,
			     hello_option_propagation_delay,
			     hello_option_override_interval,
			     hello_option_dr_priority,
			     hello_option_generation_id,
			     hello_option_addr_list);
    if (!neigh) {
      if (PIM_DEBUG_PIM_HELLO) {
	char src_str[100];
	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
	zlog_warn("%s: failure creating PIM neighbor %s on interface %s",
		  __PRETTY_FUNCTION__,
		  src_str, ifp->name);
      }
      FREE_ADDR_LIST_THEN_RETURN(-8);
    }

    /* actual addr list has been saved under neighbor */
    return 0;
  }

  /*
    Received generation ID ?
  */
  
  if (PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_GENERATION_ID)) {
    /* GenID mismatch ? */
    if (!PIM_OPTION_IS_SET(neigh->hello_options, PIM_OPTION_MASK_GENERATION_ID) ||
	(hello_option_generation_id != neigh->generation_id)) {

      /* GenID changed */

      pim_upstream_rpf_genid_changed(neigh->source_addr);

      /* GenID mismatch, then replace neighbor */
      
      if (PIM_DEBUG_PIM_HELLO) {
	char src_str[100];
	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
	zlog_debug("%s: GenId mismatch new=%08x old=%08x: replacing neighbor %s on %s",
		   __PRETTY_FUNCTION__,
		   hello_option_generation_id,
		   neigh->generation_id,
		   src_str, ifp->name);
      }

      pim_upstream_rpf_genid_changed(neigh->source_addr);
      
      pim_neighbor_delete(ifp, neigh, "GenID mismatch");
      neigh = pim_neighbor_add(ifp, src_addr,
			       hello_options,
			       hello_option_holdtime,
			       hello_option_propagation_delay,
			       hello_option_override_interval,
			       hello_option_dr_priority,
			       hello_option_generation_id,
			       hello_option_addr_list);
      if (!neigh) {
	if (PIM_DEBUG_PIM_HELLO) {
	  char src_str[100];
	  pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
	  zlog_debug("%s: failure re-creating PIM neighbor %s on interface %s",
		     __PRETTY_FUNCTION__,
		     src_str, ifp->name);
	}
	FREE_ADDR_LIST_THEN_RETURN(-9);
      }
      /* actual addr list is saved under neighbor */
      return 0;

    } /* GenId mismatch: replace neighbor */
    
  } /* GenId received */

  /*
    Update existing neighbor
  */

  pim_neighbor_update(neigh,
		      hello_options,
		      hello_option_holdtime,
		      hello_option_dr_priority,
		      hello_option_addr_list);
  /* actual addr list is saved under neighbor */
  return 0;
}

int pim_hello_build_tlv(const char *ifname,
			uint8_t *tlv_buf, int tlv_buf_size,
			uint16_t holdtime,
			uint32_t dr_priority,
			uint32_t generation_id,
			uint16_t propagation_delay,
			uint16_t override_interval,
			int can_disable_join_suppression,
			struct list *ifconnected)
{
  uint8_t *curr = tlv_buf;
  uint8_t *pastend = tlv_buf + tlv_buf_size;
  uint8_t *tmp;

  /*
   * Append options
   */

  /* Holdtime */
  curr = pim_tlv_append_uint16(curr,
			       pastend,
			       PIM_MSG_OPTION_TYPE_HOLDTIME,
			       holdtime);
  if (!curr) {
    if (PIM_DEBUG_PIM_HELLO) {
      zlog_debug("%s: could not set PIM hello Holdtime option for interface %s",
		 __PRETTY_FUNCTION__, ifname);
    }
    return -1;
  }

  /* LAN Prune Delay */
  tmp = pim_tlv_append_2uint16(curr,
			       pastend,
			       PIM_MSG_OPTION_TYPE_LAN_PRUNE_DELAY,
			       propagation_delay,
			       override_interval);
  if (!tmp) {
    if (PIM_DEBUG_PIM_HELLO) {
      zlog_debug("%s: could not set PIM LAN Prune Delay option for interface %s",
		 __PRETTY_FUNCTION__, ifname);
    }
    return -1;
  }
  if (can_disable_join_suppression) {
    *((uint8_t*)(curr) + 4) |= 0x80; /* enable T bit */
  }
  curr = tmp;

  /* DR Priority */
  curr = pim_tlv_append_uint32(curr,
			       pastend,
			       PIM_MSG_OPTION_TYPE_DR_PRIORITY,
			       dr_priority);
  if (!curr) {
    if (PIM_DEBUG_PIM_HELLO) {
      zlog_debug("%s: could not set PIM hello DR Priority option for interface %s",
		 __PRETTY_FUNCTION__, ifname);
    }
    return -2;
  }

  /* Generation ID */
  curr = pim_tlv_append_uint32(curr,
			       pastend,
			       PIM_MSG_OPTION_TYPE_GENERATION_ID,
			       generation_id);
  if (!curr) {
    if (PIM_DEBUG_PIM_HELLO) {
      zlog_debug("%s: could not set PIM hello Generation ID option for interface %s",
		 __PRETTY_FUNCTION__, ifname);
    }
    return -3;
  }

  /* Secondary Address List */
  if (ifconnected) {
    curr = pim_tlv_append_addrlist_ucast(curr,
					 pastend,
					 ifconnected);
    if (!curr) {
      if (PIM_DEBUG_PIM_HELLO) {
	zlog_debug("%s: could not set PIM hello Secondary Address List option for interface %s",
		  __PRETTY_FUNCTION__, ifname);
      }
      return -4;
    }
  }

  return curr - tlv_buf;
}

/*
  RFC 4601: 4.3.1.  Sending Hello Messages

  Thus, if a router needs to send a Join/Prune or Assert message on an
  interface on which it has not yet sent a Hello message with the
  currently configured IP address, then it MUST immediately send the
  relevant Hello message without waiting for the Hello Timer to
  expire, followed by the Join/Prune or Assert message.
*/
void pim_hello_require(struct interface *ifp)
{
  struct pim_interface *pim_ifp;

  zassert(ifp);

  pim_ifp = ifp->info;

  zassert(pim_ifp);

  if (pim_ifp->pim_ifstat_hello_sent)
    return;

  pim_hello_restart_now(ifp); /* Send hello and restart timer */
}
Commit	Line	Data
12e41d03 DL	1	/*
	2	PIM for Quagga
	3	Copyright (C) 2008 Everton da Silva Marques
	4
	5	This program is free software; you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation; either version 2 of the License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful, but
	11	WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
	16	along with this program; see the file COPYING; if not, write to the
	17	Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
	18	MA 02110-1301 USA
12e41d03 DL	19	*/
	20
	21	#include <zebra.h>
	22
	23	#include "log.h"
744d91b3	24	#include "if.h"
12e41d03 DL	25
	26	#include "pimd.h"
	27	#include "pim_pim.h"
	28	#include "pim_str.h"
	29	#include "pim_tlv.h"
	30	#include "pim_util.h"
	31	#include "pim_hello.h"
	32	#include "pim_iface.h"
	33	#include "pim_neighbor.h"
	34	#include "pim_upstream.h"
	35
	36	static void on_trace(const char *label,
	37	struct interface *ifp, struct in_addr src)
	38	{
	39	if (PIM_DEBUG_PIM_TRACE) {
	40	char src_str[100];
	41	pim_inet4_dump("<src?>", src, src_str, sizeof(src_str));
	42	zlog_debug("%s: from %s on %s",
	43	label, src_str, ifp->name);
	44	}
	45	}
	46
	47	static void tlv_trace_bool(const char label, const char tlv_name,
	48	const char *ifname, struct in_addr src_addr,
	49	int isset, int value)
	50	{
	51	if (isset) {
	52	char src_str[100];
	53	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
	54	zlog_debug("%s: PIM hello option from %s on interface %s: %s=%d",
	55	label,
	56	src_str, ifname,
	57	tlv_name, value);
	58	}
	59	}
	60
	61	static void tlv_trace_uint16(const char label, const char tlv_name,
	62	const char *ifname, struct in_addr src_addr,
	63	int isset, uint16_t value)
	64	{
	65	if (isset) {
	66	char src_str[100];
	67	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
	68	zlog_debug("%s: PIM hello option from %s on interface %s: %s=%u",
	69	label,
	70	src_str, ifname,
	71	tlv_name, value);
	72	}
	73	}
	74
	75	static void tlv_trace_uint32(const char label, const char tlv_name,
	76	const char *ifname, struct in_addr src_addr,
	77	int isset, uint32_t value)
	78	{
	79	if (isset) {
	80	char src_str[100];
	81	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
	82	zlog_debug("%s: PIM hello option from %s on interface %s: %s=%u",
	83	label,
	84	src_str, ifname,
	85	tlv_name, value);
	86	}
	87	}
	88
89	static void tlv_trace_uint32_hex(const char label, const char tlv_name,
90	const char *ifname, struct in_addr src_addr,
91	int isset, uint32_t value)
92	{
93	if (isset) {
94	char src_str[100];
95	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
96	zlog_debug("%s: PIM hello option from %s on interface %s: %s=%08x",
97	label,
98	src_str, ifname,
99	tlv_name, value);
100	}
101	}
102
103	#if 0
104	static void tlv_trace(const char label, const char tlv_name,
105	const char *ifname, struct in_addr src_addr,
106	int isset)
107	{
108	if (isset) {
109	char src_str[100];
110	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
111	zlog_debug("%s: PIM hello option from %s on interface %s: %s",
112	label,
113	src_str, ifname,
114	tlv_name);
115	}
116	}
117	#endif
118
119	static void tlv_trace_list(const char label, const char tlv_name,
120	const char *ifname, struct in_addr src_addr,
121	int isset, struct list *addr_list)
122	{
123	if (isset) {
124	char src_str[100];
125	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
126	zlog_debug("%s: PIM hello option from %s on interface %s: %s size=%d list=%p",
127	label,
128	src_str, ifname,
129	tlv_name,
130	addr_list ? ((int) listcount(addr_list)) : -1,
131	(void *) addr_list);
132	}
133	}
134
135	#define FREE_ADDR_LIST \
136	if (hello_option_addr_list) { \
137	list_delete(hello_option_addr_list); \
138	}
139
140	#define FREE_ADDR_LIST_THEN_RETURN(code) \
141	{ \
142	FREE_ADDR_LIST \
143	return (code); \
144	}
145
146	int pim_hello_recv(struct interface *ifp,
147	struct in_addr src_addr,
148	uint8_t *tlv_buf, int tlv_buf_size)
149	{
150	struct pim_interface *pim_ifp;
151	struct pim_neighbor *neigh;
152	uint8_t *tlv_curr;
153	uint8_t *tlv_pastend;
154	pim_hello_options hello_options = 0; /* bit array recording options found */
155	uint16_t hello_option_holdtime = 0;
156	uint16_t hello_option_propagation_delay = 0;
157	uint16_t hello_option_override_interval = 0;
158	uint32_t hello_option_dr_priority = 0;
159	uint32_t hello_option_generation_id = 0;
160	struct list *hello_option_addr_list = 0;
161
aea6cb94 DS	162	if (PIM_DEBUG_PIM_HELLO)
aea6cb94 DS	163	on_trace(__PRETTY_FUNCTION__, ifp, src_addr);
12e41d03 DL	164
	165	pim_ifp = ifp->info;
	166	zassert(pim_ifp);
	167
	168	++pim_ifp->pim_ifstat_hello_recv;
	169
	170	/*
	171	Parse PIM hello TLVs
	172	*/
	173	zassert(tlv_buf_size >= 0);
	174	tlv_curr = tlv_buf;
	175	tlv_pastend = tlv_buf + tlv_buf_size;
	176
	177	while (tlv_curr < tlv_pastend) {
	178	uint16_t option_type;
	179	uint16_t option_len;
	180	int remain = tlv_pastend - tlv_curr;
	181
	182	if (remain < PIM_TLV_MIN_SIZE) {
aea6cb94 DS	183	if (PIM_DEBUG_PIM_HELLO) {
	184	char src_str[100];
	185	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
	186	zlog_debug("%s: short PIM hello TLV size=%d < min=%d from %s on interface %s",
	187	__PRETTY_FUNCTION__,
	188	remain, PIM_TLV_MIN_SIZE,
	189	src_str, ifp->name);
	190	}
12e41d03 DL	191	FREE_ADDR_LIST_THEN_RETURN(-1);
	192	}
	193
	194	option_type = PIM_TLV_GET_TYPE(tlv_curr);
	195	tlv_curr += PIM_TLV_TYPE_SIZE;
	196	option_len = PIM_TLV_GET_LENGTH(tlv_curr);
	197	tlv_curr += PIM_TLV_LENGTH_SIZE;
	198
	199	if ((tlv_curr + option_len) > tlv_pastend) {
aea6cb94 DS	200	if (PIM_DEBUG_PIM_HELLO) {
	201	char src_str[100];
	202	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
	203	zlog_debug("%s: long PIM hello TLV type=%d length=%d > left=%td from %s on interface %s",
	204	__PRETTY_FUNCTION__,
	205	option_type, option_len, tlv_pastend - tlv_curr,
	206	src_str, ifp->name);
	207	}
12e41d03 DL	208	FREE_ADDR_LIST_THEN_RETURN(-2);
	209	}
	210
aea6cb94	211	if (PIM_DEBUG_PIM_HELLO) {
12e41d03 DL	212	char src_str[100];
	213	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
	214	zlog_debug("%s: parse left_size=%d: PIM hello TLV type=%d length=%d from %s on %s",
	215	__PRETTY_FUNCTION__,
	216	remain,
	217	option_type, option_len,
	218	src_str, ifp->name);
	219	}
	220
	221	switch (option_type) {
	222	case PIM_MSG_OPTION_TYPE_HOLDTIME:
	223	if (pim_tlv_parse_holdtime(ifp->name, src_addr,
	224	&hello_options,
	225	&hello_option_holdtime,
	226	option_len,
	227	tlv_curr)) {
	228	FREE_ADDR_LIST_THEN_RETURN(-3);
	229	}
	230	break;
	231	case PIM_MSG_OPTION_TYPE_LAN_PRUNE_DELAY:
	232	if (pim_tlv_parse_lan_prune_delay(ifp->name, src_addr,
	233	&hello_options,
	234	&hello_option_propagation_delay,
	235	&hello_option_override_interval,
	236	option_len,
	237	tlv_curr)) {
	238	FREE_ADDR_LIST_THEN_RETURN(-4);
	239	}
	240	break;
	241	case PIM_MSG_OPTION_TYPE_DR_PRIORITY:
	242	if (pim_tlv_parse_dr_priority(ifp->name, src_addr,
	243	&hello_options,
	244	&hello_option_dr_priority,
	245	option_len,
	246	tlv_curr)) {
	247	FREE_ADDR_LIST_THEN_RETURN(-5);
	248	}
	249	break;
	250	case PIM_MSG_OPTION_TYPE_GENERATION_ID:
	251	if (pim_tlv_parse_generation_id(ifp->name, src_addr,
	252	&hello_options,
	253	&hello_option_generation_id,
	254	option_len,
	255	tlv_curr)) {
	256	FREE_ADDR_LIST_THEN_RETURN(-6);
	257	}
	258	break;
	259	case PIM_MSG_OPTION_TYPE_ADDRESS_LIST:
	260	if (pim_tlv_parse_addr_list(ifp->name, src_addr,
	261	&hello_options,
	262	&hello_option_addr_list,
	263	option_len,
	264	tlv_curr)) {
	265	return -7;
	266	}
	267	break;
	268	case PIM_MSG_OPTION_TYPE_DM_STATE_REFRESH:
aea6cb94	269	if (PIM_DEBUG_PIM_HELLO) {
12e41d03 DL	270	char src_str[100];
	271	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
	272	zlog_debug("%s: ignoring PIM hello dense-mode state refresh TLV option type=%d length=%d from %s on interface %s",
	273	__PRETTY_FUNCTION__,
	274	option_type, option_len,
	275	src_str, ifp->name);
	276	}
	277	break;
	278	default:
aea6cb94	279	if (PIM_DEBUG_PIM_HELLO) {
12e41d03 DL	280	char src_str[100];
12e41d03 DL	281	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
aea6cb94 DS	282	zlog_debug("%s: ignoring unknown PIM hello TLV type=%d length=%d from %s on interface %s",
	283	__PRETTY_FUNCTION__,
	284	option_type, option_len,
	285	src_str, ifp->name);
12e41d03 DL	286	}
	287	}
	288
	289	tlv_curr += option_len;
	290	}
	291
	292	/*
	293	Check received PIM hello options
	294	*/
	295
aea6cb94	296	if (PIM_DEBUG_PIM_HELLO) {
12e41d03 DL	297	tlv_trace_uint16(__PRETTY_FUNCTION__, "holdtime",
	298	ifp->name, src_addr,
	299	PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_HOLDTIME),
	300	hello_option_holdtime);
	301	tlv_trace_uint16(__PRETTY_FUNCTION__, "propagation_delay",
	302	ifp->name, src_addr,
	303	PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_LAN_PRUNE_DELAY),
	304	hello_option_propagation_delay);
	305	tlv_trace_uint16(__PRETTY_FUNCTION__, "override_interval",
	306	ifp->name, src_addr,
	307	PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_LAN_PRUNE_DELAY),
	308	hello_option_override_interval);
	309	tlv_trace_bool(__PRETTY_FUNCTION__, "can_disable_join_suppression",
	310	ifp->name, src_addr,
	311	PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_LAN_PRUNE_DELAY),
	312	PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_CAN_DISABLE_JOIN_SUPPRESSION));
	313	tlv_trace_uint32(__PRETTY_FUNCTION__, "dr_priority",
	314	ifp->name, src_addr,
	315	PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_DR_PRIORITY),
	316	hello_option_dr_priority);
	317	tlv_trace_uint32_hex(__PRETTY_FUNCTION__, "generation_id",
	318	ifp->name, src_addr,
	319	PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_GENERATION_ID),
	320	hello_option_generation_id);
	321	tlv_trace_list(__PRETTY_FUNCTION__, "address_list",
	322	ifp->name, src_addr,
	323	PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_ADDRESS_LIST),
	324	hello_option_addr_list);
	325	}
	326
	327	if (!PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_HOLDTIME)) {
aea6cb94 DS	328	if (PIM_DEBUG_PIM_HELLO) {
	329	char src_str[100];
	330	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
	331	zlog_debug("%s: PIM hello missing holdtime from %s on interface %s",
	332	__PRETTY_FUNCTION__,
	333	src_str, ifp->name);
	334	}
12e41d03 DL	335	}
	336
	337	/*
	338	New neighbor?
	339	*/
	340
	341	neigh = pim_neighbor_find(ifp, src_addr);
	342	if (!neigh) {
	343	/* Add as new neighbor */
	344
	345	neigh = pim_neighbor_add(ifp, src_addr,
	346	hello_options,
	347	hello_option_holdtime,
	348	hello_option_propagation_delay,
	349	hello_option_override_interval,
	350	hello_option_dr_priority,
	351	hello_option_generation_id,
	352	hello_option_addr_list);
	353	if (!neigh) {
aea6cb94 DS	354	if (PIM_DEBUG_PIM_HELLO) {
	355	char src_str[100];
	356	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
	357	zlog_warn("%s: failure creating PIM neighbor %s on interface %s",
	358	__PRETTY_FUNCTION__,
	359	src_str, ifp->name);
	360	}
12e41d03 DL	361	FREE_ADDR_LIST_THEN_RETURN(-8);
	362	}
	363
	364	/* actual addr list has been saved under neighbor */
	365	return 0;
	366	}
	367
	368	/*
	369	Received generation ID ?
	370	*/
	371
	372	if (PIM_OPTION_IS_SET(hello_options, PIM_OPTION_MASK_GENERATION_ID)) {
	373	/* GenID mismatch ? */
	374	if (!PIM_OPTION_IS_SET(neigh->hello_options, PIM_OPTION_MASK_GENERATION_ID) \|\|
	375	(hello_option_generation_id != neigh->generation_id)) {
	376
	377	/* GenID changed */
	378
	379	pim_upstream_rpf_genid_changed(neigh->source_addr);
	380
	381	/* GenID mismatch, then replace neighbor */
	382
aea6cb94	383	if (PIM_DEBUG_PIM_HELLO) {
12e41d03 DL	384	char src_str[100];
	385	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
	386	zlog_debug("%s: GenId mismatch new=%08x old=%08x: replacing neighbor %s on %s",
	387	__PRETTY_FUNCTION__,
	388	hello_option_generation_id,
	389	neigh->generation_id,
	390	src_str, ifp->name);
	391	}
	392
	393	pim_upstream_rpf_genid_changed(neigh->source_addr);
	394
	395	pim_neighbor_delete(ifp, neigh, "GenID mismatch");
	396	neigh = pim_neighbor_add(ifp, src_addr,
	397	hello_options,
	398	hello_option_holdtime,
	399	hello_option_propagation_delay,
	400	hello_option_override_interval,
	401	hello_option_dr_priority,
	402	hello_option_generation_id,
	403	hello_option_addr_list);
	404	if (!neigh) {
aea6cb94 DS	405	if (PIM_DEBUG_PIM_HELLO) {
	406	char src_str[100];
	407	pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
	408	zlog_debug("%s: failure re-creating PIM neighbor %s on interface %s",
	409	__PRETTY_FUNCTION__,
	410	src_str, ifp->name);
	411	}
12e41d03 DL	412	FREE_ADDR_LIST_THEN_RETURN(-9);
	413	}
	414	/* actual addr list is saved under neighbor */
	415	return 0;
	416
	417	} /* GenId mismatch: replace neighbor */
	418
	419	} /* GenId received */
	420
	421	/*
	422	Update existing neighbor
	423	*/
	424
	425	pim_neighbor_update(neigh,
	426	hello_options,
	427	hello_option_holdtime,
	428	hello_option_dr_priority,
	429	hello_option_addr_list);
	430	/* actual addr list is saved under neighbor */
	431	return 0;
	432	}
	433
	434	int pim_hello_build_tlv(const char *ifname,
	435	uint8_t *tlv_buf, int tlv_buf_size,
	436	uint16_t holdtime,
	437	uint32_t dr_priority,
	438	uint32_t generation_id,
	439	uint16_t propagation_delay,
	440	uint16_t override_interval,
	441	int can_disable_join_suppression,
	442	struct list *ifconnected)
	443	{
	444	uint8_t *curr = tlv_buf;
	445	uint8_t *pastend = tlv_buf + tlv_buf_size;
	446	uint8_t *tmp;
	447
	448	/*
	449	* Append options
	450	*/
	451
	452	/* Holdtime */
	453	curr = pim_tlv_append_uint16(curr,
	454	pastend,
	455	PIM_MSG_OPTION_TYPE_HOLDTIME,
	456	holdtime);
	457	if (!curr) {
aea6cb94 DS	458	if (PIM_DEBUG_PIM_HELLO) {
	459	zlog_debug("%s: could not set PIM hello Holdtime option for interface %s",
	460	__PRETTY_FUNCTION__, ifname);
	461	}
12e41d03 DL	462	return -1;
	463	}
	464
	465	/* LAN Prune Delay */
	466	tmp = pim_tlv_append_2uint16(curr,
	467	pastend,
	468	PIM_MSG_OPTION_TYPE_LAN_PRUNE_DELAY,
	469	propagation_delay,
	470	override_interval);
	471	if (!tmp) {
aea6cb94 DS	472	if (PIM_DEBUG_PIM_HELLO) {
	473	zlog_debug("%s: could not set PIM LAN Prune Delay option for interface %s",
	474	__PRETTY_FUNCTION__, ifname);
	475	}
12e41d03 DL	476	return -1;
	477	}
	478	if (can_disable_join_suppression) {
	479	((uint8_t)(curr) + 4) \|= 0x80; /* enable T bit */
	480	}
	481	curr = tmp;
	482
	483	/* DR Priority */
	484	curr = pim_tlv_append_uint32(curr,
	485	pastend,
	486	PIM_MSG_OPTION_TYPE_DR_PRIORITY,
	487	dr_priority);
	488	if (!curr) {
aea6cb94 DS	489	if (PIM_DEBUG_PIM_HELLO) {
	490	zlog_debug("%s: could not set PIM hello DR Priority option for interface %s",
	491	__PRETTY_FUNCTION__, ifname);
	492	}
12e41d03 DL	493	return -2;
	494	}
	495
	496	/* Generation ID */
	497	curr = pim_tlv_append_uint32(curr,
	498	pastend,
	499	PIM_MSG_OPTION_TYPE_GENERATION_ID,
	500	generation_id);
	501	if (!curr) {
aea6cb94 DS	502	if (PIM_DEBUG_PIM_HELLO) {
	503	zlog_debug("%s: could not set PIM hello Generation ID option for interface %s",
	504	__PRETTY_FUNCTION__, ifname);
	505	}
12e41d03 DL	506	return -3;
	507	}
	508
	509	/* Secondary Address List */
	510	if (ifconnected) {
	511	curr = pim_tlv_append_addrlist_ucast(curr,
	512	pastend,
	513	ifconnected);
	514	if (!curr) {
aea6cb94 DS	515	if (PIM_DEBUG_PIM_HELLO) {
	516	zlog_debug("%s: could not set PIM hello Secondary Address List option for interface %s",
	517	__PRETTY_FUNCTION__, ifname);
	518	}
12e41d03 DL	519	return -4;
	520	}
	521	}
	522
	523	return curr - tlv_buf;
	524	}
	525
	526	/*
	527	RFC 4601: 4.3.1. Sending Hello Messages
	528
	529	Thus, if a router needs to send a Join/Prune or Assert message on an
	530	interface on which it has not yet sent a Hello message with the
	531	currently configured IP address, then it MUST immediately send the
	532	relevant Hello message without waiting for the Hello Timer to
	533	expire, followed by the Join/Prune or Assert message.
	534	*/
	535	void pim_hello_require(struct interface *ifp)
	536	{
	537	struct pim_interface *pim_ifp;
	538
	539	zassert(ifp);
	540
	541	pim_ifp = ifp->info;
	542
	543	zassert(pim_ifp);
	544
	545	if (pim_ifp->pim_ifstat_hello_sent)
	546	return;
	547
	548	pim_hello_restart_now(ifp); /* Send hello and restart timer */
	549	}