static int igmp_v1_report(struct igmp_sock *igmp,
struct in_addr from, const char *from_str,
char *igmp_msg, int igmp_msg_len)
{
struct interface *ifp = igmp->interface;
struct igmp_group *group;
struct in_addr group_addr;
on_trace(__PRETTY_FUNCTION__, igmp->interface, from);
if (igmp_msg_len != IGMP_V12_MSG_SIZE) {
zlog_warn("Recv IGMP report v1 from %s on %s: size=%d other than correct=%d",
from_str, ifp->name, igmp_msg_len, IGMP_V12_MSG_SIZE);
return -1;
}
if (PIM_DEBUG_IGMP_TRACE) {
zlog_warn("%s %s: FIXME WRITEME",
__FILE__, __PRETTY_FUNCTION__);
}
//group_addr = *(struct in_addr *)(igmp_msg + 4);
memcpy(&group_addr, igmp_msg + 4, sizeof(struct in_addr));
/* non-existant group is created as INCLUDE {empty} */
group = igmp_add_group_by_addr(igmp, group_addr, ifp->name);
if (!group) {
return -1;
}
group->last_igmp_v1_report_dsec = pim_time_monotonic_dsec();
return 0;
}
static int igmp_v2_leave(struct igmp_sock *igmp,
struct in_addr from, const char *from_str,
char *igmp_msg, int igmp_msg_len)
{
struct interface *ifp = igmp->interface;
on_trace(__PRETTY_FUNCTION__, igmp->interface, from);
if (igmp_msg_len != IGMP_V12_MSG_SIZE) {
zlog_warn("Recv IGMP leave v2 from %s on %s: size=%d other than correct=%d",
from_str, ifp->name, igmp_msg_len, IGMP_V12_MSG_SIZE);
return -1;
}
if (PIM_DEBUG_IGMP_TRACE) {
zlog_warn("%s %s: FIXME WRITEME",
__FILE__, __PRETTY_FUNCTION__);
}
return 0;
}
int pim_assert_recv(struct interface *ifp,
struct pim_neighbor *neigh,
struct in_addr src_addr,
uint8_t *buf, int buf_size)
{
struct prefix msg_group_addr;
struct prefix msg_source_addr;
struct pim_assert_metric msg_metric;
int offset;
uint8_t *curr;
int curr_size;
on_trace(__PRETTY_FUNCTION__, ifp, src_addr);
curr = buf;
curr_size = buf_size;
/*
Parse assert group addr
*/
offset = pim_parse_addr_group(ifp->name, src_addr,
&msg_group_addr,
curr, curr_size);
if (offset < 1) {
char src_str[100];
pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
zlog_warn("%s: pim_parse_addr_group() failure: from %s on %s",
__PRETTY_FUNCTION__,
src_str, ifp->name);
return -1;
}
curr += offset;
curr_size -= offset;
/*
Parse assert source addr
*/
offset = pim_parse_addr_ucast(ifp->name, src_addr,
&msg_source_addr,
curr, curr_size);
if (offset < 1) {
char src_str[100];
pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
zlog_warn("%s: pim_parse_addr_ucast() failure: from %s on %s",
__PRETTY_FUNCTION__,
src_str, ifp->name);
return -2;
}
curr += offset;
curr_size -= offset;
if (curr_size != 8) {
char src_str[100];
pim_inet4_dump("<src?>", src_addr, src_str, sizeof(src_str));
zlog_warn("%s: preference/metric size is not 8: size=%d from %s on interface %s",
__PRETTY_FUNCTION__,
curr_size,
src_str, ifp->name);
return -3;
}
/*
Parse assert metric preference
*/
msg_metric.metric_preference = pim_read_uint32_host(curr);
msg_metric.rpt_bit_flag = msg_metric.metric_preference & 0x80000000; /* save highest bit */
msg_metric.metric_preference &= ~0x80000000; /* clear highest bit */
curr += 4;
/*
Parse assert route metric
*/
msg_metric.route_metric = pim_read_uint32_host(curr);
if (PIM_DEBUG_PIM_TRACE) {
char neigh_str[100];
char source_str[100];
char group_str[100];
pim_inet4_dump("<neigh?>", src_addr, neigh_str, sizeof(neigh_str));
pim_inet4_dump("<src?>", msg_source_addr.u.prefix4, source_str, sizeof(source_str));
pim_inet4_dump("<grp?>", msg_group_addr.u.prefix4, group_str, sizeof(group_str));
zlog_debug("%s: from %s on %s: (S,G)=(%s,%s) pref=%u metric=%u rpt_bit=%u",
__PRETTY_FUNCTION__, neigh_str, ifp->name,
source_str, group_str,
msg_metric.metric_preference,
msg_metric.route_metric,
PIM_FORCE_BOOLEAN(msg_metric.rpt_bit_flag));
}
msg_metric.ip_address = src_addr;
return dispatch_assert(ifp,
msg_source_addr.u.prefix4,
msg_group_addr.u.prefix4,
msg_metric);
}
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[INET_ADDRSTRLEN];
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[INET_ADDRSTRLEN];
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[INET_ADDRSTRLEN];
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[INET_ADDRSTRLEN];
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[INET_ADDRSTRLEN];
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[INET_ADDRSTRLEN];
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, PIM_NEIGHBOR_SEND_DELAY);
if (!neigh) {
if (PIM_DEBUG_PIM_HELLO) {
char src_str[INET_ADDRSTRLEN];
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 mismatch, then replace neighbor */
if (PIM_DEBUG_PIM_HELLO) {
char src_str[INET_ADDRSTRLEN];
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(pim_ifp->pim,
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,
PIM_NEIGHBOR_SEND_NOW);
if (!neigh) {
if (PIM_DEBUG_PIM_HELLO) {
char src_str[INET_ADDRSTRLEN];
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;
}