int pim_pim_packet(struct interface *ifp, uint8_t *buf, size_t len)
{
struct ip *ip_hdr;
size_t ip_hlen; /* ip header length in bytes */
char src_str[100];
char dst_str[100];
uint8_t *pim_msg;
int pim_msg_len;
uint8_t pim_version;
uint8_t pim_type;
uint16_t pim_checksum; /* received checksum */
uint16_t checksum; /* computed checksum */
struct pim_neighbor *neigh;
if (!ifp->info) {
zlog_warn("%s: PIM not enabled on interface %s",
__PRETTY_FUNCTION__, ifp->name);
return -1;
}
if (len < sizeof(*ip_hdr)) {
zlog_warn("PIM packet size=%zu shorter than minimum=%zu",
len, sizeof(*ip_hdr));
return -1;
}
ip_hdr = (struct ip *) buf;
pim_inet4_dump("<src?>", ip_hdr->ip_src, src_str, sizeof(src_str));
pim_inet4_dump("<dst?>", ip_hdr->ip_dst, dst_str, sizeof(dst_str));
ip_hlen = ip_hdr->ip_hl << 2; /* ip_hl gives length in 4-byte words */
if (PIM_DEBUG_PIM_PACKETS) {
zlog_debug("Recv IP packet from %s to %s on %s: size=%zu ip_header_size=%zu ip_proto=%d",
src_str, dst_str, ifp->name, len, ip_hlen, ip_hdr->ip_p);
}
if (ip_hdr->ip_p != PIM_IP_PROTO_PIM) {
zlog_warn("IP packet protocol=%d is not PIM=%d",
ip_hdr->ip_p, PIM_IP_PROTO_PIM);
return -1;
}
if (ip_hlen < PIM_IP_HEADER_MIN_LEN) {
zlog_warn("IP packet header size=%zu shorter than minimum=%d",
ip_hlen, PIM_IP_HEADER_MIN_LEN);
return -1;
}
if (ip_hlen > PIM_IP_HEADER_MAX_LEN) {
zlog_warn("IP packet header size=%zu greater than maximum=%d",
ip_hlen, PIM_IP_HEADER_MAX_LEN);
return -1;
}
pim_msg = buf + ip_hlen;
pim_msg_len = len - ip_hlen;
if (PIM_DEBUG_PIM_PACKETDUMP_RECV) {
pim_pkt_dump(__PRETTY_FUNCTION__, pim_msg, pim_msg_len);
}
if (pim_msg_len < PIM_PIM_MIN_LEN) {
zlog_warn("PIM message size=%d shorter than minimum=%d",
pim_msg_len, PIM_PIM_MIN_LEN);
return -1;
}
pim_version = PIM_MSG_HDR_GET_VERSION(pim_msg);
pim_type = PIM_MSG_HDR_GET_TYPE(pim_msg);
if (pim_version != PIM_PROTO_VERSION) {
zlog_warn("Ignoring PIM pkt from %s with unsupported version: %d",
ifp->name, pim_version);
return -1;
}
/* save received checksum */
pim_checksum = PIM_MSG_HDR_GET_CHECKSUM(pim_msg);
/* for computing checksum */
*(uint16_t *) PIM_MSG_HDR_OFFSET_CHECKSUM(pim_msg) = 0;
checksum = in_cksum(pim_msg, pim_msg_len);
if (checksum != pim_checksum) {
zlog_warn("Ignoring PIM pkt from %s with invalid checksum: received=%x calculated=%x",
ifp->name, pim_checksum, checksum);
return -1;
}
if (PIM_DEBUG_PIM_PACKETS) {
zlog_debug("Recv PIM packet from %s to %s on %s: ttl=%d pim_version=%d pim_type=%d pim_msg_size=%d checksum=%x",
src_str, dst_str, ifp->name, ip_hdr->ip_ttl,
pim_version, pim_type, pim_msg_len, checksum);
}
if (pim_type == PIM_MSG_TYPE_REGISTER ||
pim_type == PIM_MSG_TYPE_REG_STOP ||
pim_type == PIM_MSG_TYPE_BOOTSTRAP ||
pim_type == PIM_MSG_TYPE_GRAFT ||
pim_type == PIM_MSG_TYPE_GRAFT_ACK ||
pim_type == PIM_MSG_TYPE_CANDIDATE)
{
if (PIM_DEBUG_PIM_PACKETS) {
zlog_debug("Recv PIM packet type %d which is not currently understood",
pim_type);
}
return -1;
}
if (pim_type == PIM_MSG_TYPE_HELLO) {
int result = pim_hello_recv(ifp,
ip_hdr->ip_src,
pim_msg + PIM_MSG_HEADER_LEN,
pim_msg_len - PIM_MSG_HEADER_LEN);
return result;
}
neigh = pim_neighbor_find(ifp, ip_hdr->ip_src);
if (!neigh) {
zlog_warn("%s %s: non-hello PIM message type=%d from non-neighbor %s on %s",
__FILE__, __PRETTY_FUNCTION__,
pim_type, src_str, ifp->name);
return -1;
}
switch (pim_type) {
case PIM_MSG_TYPE_JOIN_PRUNE:
return pim_joinprune_recv(ifp, neigh,
ip_hdr->ip_src,
pim_msg + PIM_MSG_HEADER_LEN,
pim_msg_len - PIM_MSG_HEADER_LEN);
case PIM_MSG_TYPE_ASSERT:
return pim_assert_recv(ifp, neigh,
ip_hdr->ip_src,
pim_msg + PIM_MSG_HEADER_LEN,
pim_msg_len - PIM_MSG_HEADER_LEN);
default:
zlog_warn("%s %s: unsupported PIM message type=%d from %s on %s",
__FILE__, __PRETTY_FUNCTION__,
pim_type, src_str, ifp->name);
}
return -1;
}
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;
}
