summaryrefslogtreecommitdiffstats
path: root/pimd/pim_pim.c
diff options
context:
space:
mode:
Diffstat (limited to 'pimd/pim_pim.c')
-rw-r--r--pimd/pim_pim.c997
1 files changed, 997 insertions, 0 deletions
diff --git a/pimd/pim_pim.c b/pimd/pim_pim.c
new file mode 100644
index 0000000..a4c9178
--- /dev/null
+++ b/pimd/pim_pim.c
@@ -0,0 +1,997 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * PIM for Quagga
+ * Copyright (C) 2008 Everton da Silva Marques
+ */
+
+#include <zebra.h>
+
+#include "log.h"
+#include "frrevent.h"
+#include "memory.h"
+#include "if.h"
+#include "network.h"
+
+#include "pimd.h"
+#include "pim_instance.h"
+#include "pim_pim.h"
+#include "pim_time.h"
+#include "pim_iface.h"
+#include "pim_sock.h"
+#include "pim_str.h"
+#include "pim_util.h"
+#include "pim_tlv.h"
+#include "pim_neighbor.h"
+#include "pim_hello.h"
+#include "pim_join.h"
+#include "pim_assert.h"
+#include "pim_msg.h"
+#include "pim_register.h"
+#include "pim_errors.h"
+#include "pim_bsm.h"
+#include <lib/lib_errors.h>
+
+static void on_pim_hello_send(struct event *t);
+
+static const char *pim_pim_msgtype2str(enum pim_msg_type type)
+{
+ switch (type) {
+ case PIM_MSG_TYPE_HELLO:
+ return "HELLO";
+ case PIM_MSG_TYPE_REGISTER:
+ return "REGISTER";
+ case PIM_MSG_TYPE_REG_STOP:
+ return "REGSTOP";
+ case PIM_MSG_TYPE_JOIN_PRUNE:
+ return "JOINPRUNE";
+ case PIM_MSG_TYPE_BOOTSTRAP:
+ return "BOOT";
+ case PIM_MSG_TYPE_ASSERT:
+ return "ASSERT";
+ case PIM_MSG_TYPE_GRAFT:
+ return "GRAFT";
+ case PIM_MSG_TYPE_GRAFT_ACK:
+ return "GACK";
+ case PIM_MSG_TYPE_CANDIDATE:
+ return "CANDIDATE";
+ }
+
+ return "UNKNOWN";
+}
+
+static void sock_close(struct interface *ifp)
+{
+ struct pim_interface *pim_ifp = ifp->info;
+
+ if (PIM_DEBUG_PIM_TRACE) {
+ if (pim_ifp->t_pim_sock_read) {
+ zlog_debug(
+ "Cancelling READ event for PIM socket fd=%d on interface %s",
+ pim_ifp->pim_sock_fd, ifp->name);
+ }
+ }
+ EVENT_OFF(pim_ifp->t_pim_sock_read);
+
+ if (PIM_DEBUG_PIM_TRACE) {
+ if (pim_ifp->t_pim_hello_timer) {
+ zlog_debug(
+ "Cancelling PIM hello timer for interface %s",
+ ifp->name);
+ }
+ }
+ EVENT_OFF(pim_ifp->t_pim_hello_timer);
+
+ if (PIM_DEBUG_PIM_TRACE) {
+ zlog_debug("Deleting PIM socket fd=%d on interface %s",
+ pim_ifp->pim_sock_fd, ifp->name);
+ }
+
+ /*
+ * If the fd is already deleted no need to do anything here
+ */
+ if (pim_ifp->pim_sock_fd > 0 && close(pim_ifp->pim_sock_fd)) {
+ zlog_warn(
+ "Failure closing PIM socket fd=%d on interface %s: errno=%d: %s",
+ pim_ifp->pim_sock_fd, ifp->name, errno,
+ safe_strerror(errno));
+ }
+
+ pim_ifp->pim_sock_fd = -1;
+ pim_ifp->pim_sock_creation = 0;
+}
+
+void pim_sock_delete(struct interface *ifp, const char *delete_message)
+{
+ zlog_info("PIM INTERFACE DOWN: on interface %s: %s", ifp->name,
+ delete_message);
+
+ if (!ifp->info) {
+ flog_err(EC_PIM_CONFIG,
+ "%s: %s: but PIM not enabled on interface %s (!)",
+ __func__, delete_message, ifp->name);
+ return;
+ }
+
+ /*
+ RFC 4601: 4.3.1. Sending Hello Messages
+
+ Before an interface goes down or changes primary IP address, a Hello
+ message with a zero HoldTime should be sent immediately (with the
+ old IP address if the IP address changed).
+ */
+ pim_hello_send(ifp, 0 /* zero-sec holdtime */);
+
+ pim_neighbor_delete_all(ifp, delete_message);
+
+ sock_close(ifp);
+}
+
+/* For now check dst address for hello, assrt and join/prune is all pim rtr */
+static bool pim_pkt_dst_addr_ok(enum pim_msg_type type, pim_addr addr)
+{
+ if ((type == PIM_MSG_TYPE_HELLO) || (type == PIM_MSG_TYPE_ASSERT)
+ || (type == PIM_MSG_TYPE_JOIN_PRUNE)) {
+ if (pim_addr_cmp(addr, qpim_all_pim_routers_addr))
+ return false;
+ }
+
+ return true;
+}
+
+int pim_pim_packet(struct interface *ifp, uint8_t *buf, size_t len,
+ pim_sgaddr sg)
+{
+ struct iovec iov[2], *iovp = iov;
+#if PIM_IPV == 4
+ struct ip *ip_hdr = (struct ip *)buf;
+ size_t ip_hlen; /* ip header length in bytes */
+#endif
+ uint8_t *pim_msg;
+ uint32_t pim_msg_len = 0;
+ uint16_t pim_checksum; /* received checksum */
+ uint16_t checksum; /* computed checksum */
+ struct pim_neighbor *neigh;
+ struct pim_msg_header *header;
+ bool no_fwd;
+
+#if PIM_IPV == 4
+ if (len <= sizeof(*ip_hdr)) {
+ if (PIM_DEBUG_PIM_PACKETS)
+ zlog_debug(
+ "PIM packet size=%zu shorter than minimum=%zu",
+ len, sizeof(*ip_hdr));
+ return -1;
+ }
+
+ ip_hlen = ip_hdr->ip_hl << 2; /* ip_hl gives length in 4-byte words */
+ sg = pim_sgaddr_from_iphdr(ip_hdr);
+
+ pim_msg = buf + ip_hlen;
+ pim_msg_len = len - ip_hlen;
+#else
+ struct ipv6_ph phdr = {
+ .src = sg.src,
+ .dst = sg.grp,
+ .ulpl = htonl(len),
+ .next_hdr = IPPROTO_PIM,
+ };
+
+ iovp->iov_base = &phdr;
+ iovp->iov_len = sizeof(phdr);
+ iovp++;
+
+ /* NB: header is not included in IPv6 RX */
+ pim_msg = buf;
+ pim_msg_len = len;
+#endif
+
+ iovp->iov_base = pim_msg;
+ iovp->iov_len = pim_msg_len;
+ iovp++;
+
+ if (pim_msg_len < PIM_PIM_MIN_LEN) {
+ if (PIM_DEBUG_PIM_PACKETS)
+ zlog_debug(
+ "PIM message size=%d shorter than minimum=%d",
+ pim_msg_len, PIM_PIM_MIN_LEN);
+ return -1;
+ }
+ header = (struct pim_msg_header *)pim_msg;
+
+ if (header->ver != PIM_PROTO_VERSION) {
+ if (PIM_DEBUG_PIM_PACKETS)
+ zlog_debug(
+ "Ignoring PIM pkt from %s with unsupported version: %d",
+ ifp->name, header->ver);
+ return -1;
+ }
+
+ /* save received checksum */
+ pim_checksum = header->checksum;
+
+ /* for computing checksum */
+ header->checksum = 0;
+ no_fwd = header->Nbit;
+
+ if (header->type == PIM_MSG_TYPE_REGISTER) {
+ if (pim_msg_len < PIM_MSG_REGISTER_LEN) {
+ if (PIM_DEBUG_PIM_PACKETS)
+ zlog_debug("PIM Register Message size=%d shorther than min length %d",
+ pim_msg_len, PIM_MSG_REGISTER_LEN);
+ return -1;
+ }
+
+#if PIM_IPV == 6
+ phdr.ulpl = htonl(PIM_MSG_REGISTER_LEN);
+#endif
+ /* First 8 byte header checksum */
+ iovp[-1].iov_len = PIM_MSG_REGISTER_LEN;
+ checksum = in_cksumv(iov, iovp - iov);
+
+ if (checksum != pim_checksum) {
+#if PIM_IPV == 6
+ phdr.ulpl = htonl(pim_msg_len);
+#endif
+ iovp[-1].iov_len = pim_msg_len;
+
+ checksum = in_cksumv(iov, iovp - iov);
+ if (checksum != pim_checksum) {
+ if (PIM_DEBUG_PIM_PACKETS)
+ zlog_debug(
+ "Ignoring PIM pkt from %s with invalid checksum: received=%x calculated=%x",
+ ifp->name, pim_checksum,
+ checksum);
+
+ return -1;
+ }
+ }
+ } else {
+ checksum = in_cksumv(iov, iovp - iov);
+ if (checksum != pim_checksum) {
+ if (PIM_DEBUG_PIM_PACKETS)
+ zlog_debug(
+ "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 %s packet from %pPA to %pPA on %s: pim_version=%d pim_msg_size=%d checksum=%x",
+ pim_pim_msgtype2str(header->type), &sg.src, &sg.grp,
+ ifp->name, header->ver, pim_msg_len, checksum);
+ if (PIM_DEBUG_PIM_PACKETDUMP_RECV)
+ pim_pkt_dump(__func__, pim_msg, pim_msg_len);
+ }
+
+ if (!pim_pkt_dst_addr_ok(header->type, sg.grp)) {
+ zlog_warn(
+ "%s: Ignoring Pkt. Unexpected IP destination %pPA for %s (Expected: all_pim_routers_addr) from %pPA",
+ __func__, &sg.grp, pim_pim_msgtype2str(header->type),
+ &sg.src);
+ return -1;
+ }
+
+ switch (header->type) {
+ case PIM_MSG_TYPE_HELLO:
+ return pim_hello_recv(ifp, sg.src, pim_msg + PIM_MSG_HEADER_LEN,
+ pim_msg_len - PIM_MSG_HEADER_LEN);
+ break;
+ case PIM_MSG_TYPE_REGISTER:
+ return pim_register_recv(ifp, sg.grp, sg.src,
+ pim_msg + PIM_MSG_HEADER_LEN,
+ pim_msg_len - PIM_MSG_HEADER_LEN);
+ break;
+ case PIM_MSG_TYPE_REG_STOP:
+ return pim_register_stop_recv(ifp, pim_msg + PIM_MSG_HEADER_LEN,
+ pim_msg_len - PIM_MSG_HEADER_LEN);
+ break;
+ case PIM_MSG_TYPE_JOIN_PRUNE:
+ neigh = pim_neighbor_find(ifp, sg.src, false);
+ if (!neigh) {
+ if (PIM_DEBUG_PIM_PACKETS)
+ zlog_debug(
+ "%s %s: non-hello PIM message type=%d from non-neighbor %pPA on %s",
+ __FILE__, __func__, header->type,
+ &sg.src, ifp->name);
+ return -1;
+ }
+ pim_neighbor_timer_reset(neigh, neigh->holdtime);
+ return pim_joinprune_recv(ifp, neigh, sg.src,
+ pim_msg + PIM_MSG_HEADER_LEN,
+ pim_msg_len - PIM_MSG_HEADER_LEN);
+ break;
+ case PIM_MSG_TYPE_ASSERT:
+ neigh = pim_neighbor_find(ifp, sg.src, false);
+ if (!neigh) {
+ if (PIM_DEBUG_PIM_PACKETS)
+ zlog_debug(
+ "%s %s: non-hello PIM message type=%d from non-neighbor %pPA on %s",
+ __FILE__, __func__, header->type,
+ &sg.src, ifp->name);
+ return -1;
+ }
+ pim_neighbor_timer_reset(neigh, neigh->holdtime);
+ return pim_assert_recv(ifp, neigh, sg.src,
+ pim_msg + PIM_MSG_HEADER_LEN,
+ pim_msg_len - PIM_MSG_HEADER_LEN);
+ break;
+ case PIM_MSG_TYPE_BOOTSTRAP:
+ return pim_bsm_process(ifp, &sg, pim_msg, pim_msg_len, no_fwd);
+ break;
+
+ default:
+ if (PIM_DEBUG_PIM_PACKETS) {
+ zlog_debug(
+ "Recv PIM packet type %d which is not currently understood",
+ header->type);
+ }
+ return -1;
+ }
+}
+
+static void pim_sock_read_on(struct interface *ifp);
+
+static void pim_sock_read(struct event *t)
+{
+ struct interface *ifp, *orig_ifp;
+ struct pim_interface *pim_ifp;
+ int fd;
+ struct sockaddr_storage from;
+ struct sockaddr_storage to;
+ socklen_t fromlen = sizeof(from);
+ socklen_t tolen = sizeof(to);
+ uint8_t buf[PIM_PIM_BUFSIZE_READ];
+ int len;
+ ifindex_t ifindex = -1;
+ int result = -1; /* defaults to bad */
+ static long long count = 0;
+ int cont = 1;
+
+ orig_ifp = ifp = EVENT_ARG(t);
+ fd = EVENT_FD(t);
+
+ pim_ifp = ifp->info;
+
+ while (cont) {
+ pim_sgaddr sg;
+
+ len = pim_socket_recvfromto(fd, buf, sizeof(buf), &from,
+ &fromlen, &to, &tolen, &ifindex);
+ if (len < 0) {
+ if (errno == EINTR)
+ continue;
+ if (errno == EWOULDBLOCK || errno == EAGAIN)
+ break;
+
+ if (PIM_DEBUG_PIM_PACKETS)
+ zlog_debug("Received errno: %d %s", errno,
+ safe_strerror(errno));
+ goto done;
+ }
+
+ /*
+ * What? So with vrf's the incoming packet is received
+ * on the vrf interface but recvfromto above returns
+ * the right ifindex, so just use it. We know
+ * it's the right interface because we bind to it
+ */
+ ifp = if_lookup_by_index(ifindex, pim_ifp->pim->vrf->vrf_id);
+ if (!ifp || !ifp->info) {
+ if (PIM_DEBUG_PIM_PACKETS)
+ zlog_debug(
+ "%s: Received incoming pim packet on interface(%s:%d) not yet configured for pim",
+ __func__, ifp ? ifp->name : "Unknown",
+ ifindex);
+ goto done;
+ }
+#if PIM_IPV == 4
+ sg.src = ((struct sockaddr_in *)&from)->sin_addr;
+ sg.grp = ((struct sockaddr_in *)&to)->sin_addr;
+#else
+ sg.src = ((struct sockaddr_in6 *)&from)->sin6_addr;
+ sg.grp = ((struct sockaddr_in6 *)&to)->sin6_addr;
+#endif
+
+ int fail = pim_pim_packet(ifp, buf, len, sg);
+ if (fail) {
+ if (PIM_DEBUG_PIM_PACKETS)
+ zlog_debug("%s: pim_pim_packet() return=%d",
+ __func__, fail);
+ goto done;
+ }
+
+ count++;
+ if (count % router->packet_process == 0)
+ cont = 0;
+ }
+
+ result = 0; /* good */
+
+done:
+ pim_sock_read_on(orig_ifp);
+
+ if (result) {
+ ++pim_ifp->pim_ifstat_hello_recvfail;
+ }
+}
+
+static void pim_sock_read_on(struct interface *ifp)
+{
+ struct pim_interface *pim_ifp;
+
+ assert(ifp);
+ assert(ifp->info);
+
+ pim_ifp = ifp->info;
+
+ if (PIM_DEBUG_PIM_TRACE_DETAIL) {
+ zlog_debug("Scheduling READ event on PIM socket fd=%d",
+ pim_ifp->pim_sock_fd);
+ }
+ event_add_read(router->master, pim_sock_read, ifp, pim_ifp->pim_sock_fd,
+ &pim_ifp->t_pim_sock_read);
+}
+
+static int pim_sock_open(struct interface *ifp)
+{
+ int fd;
+ struct pim_interface *pim_ifp = ifp->info;
+
+ fd = pim_socket_mcast(IPPROTO_PIM, pim_ifp->primary_address, ifp,
+ 0 /* loop=false */);
+ if (fd < 0)
+ return -1;
+
+ if (pim_socket_join(fd, qpim_all_pim_routers_addr,
+ pim_ifp->primary_address, ifp->ifindex, pim_ifp)) {
+ close(fd);
+ return -2;
+ }
+
+ return fd;
+}
+
+void pim_ifstat_reset(struct interface *ifp)
+{
+ struct pim_interface *pim_ifp;
+
+ assert(ifp);
+
+ pim_ifp = ifp->info;
+ if (!pim_ifp) {
+ return;
+ }
+
+ pim_ifp->pim_ifstat_start = pim_time_monotonic_sec();
+ pim_ifp->pim_ifstat_hello_sent = 0;
+ pim_ifp->pim_ifstat_hello_sendfail = 0;
+ pim_ifp->pim_ifstat_hello_recv = 0;
+ pim_ifp->pim_ifstat_hello_recvfail = 0;
+ pim_ifp->pim_ifstat_bsm_rx = 0;
+ pim_ifp->pim_ifstat_bsm_tx = 0;
+ pim_ifp->pim_ifstat_join_recv = 0;
+ pim_ifp->pim_ifstat_join_send = 0;
+ pim_ifp->pim_ifstat_prune_recv = 0;
+ pim_ifp->pim_ifstat_prune_send = 0;
+ pim_ifp->pim_ifstat_reg_recv = 0;
+ pim_ifp->pim_ifstat_reg_send = 0;
+ pim_ifp->pim_ifstat_reg_stop_recv = 0;
+ pim_ifp->pim_ifstat_reg_stop_send = 0;
+ pim_ifp->pim_ifstat_assert_recv = 0;
+ pim_ifp->pim_ifstat_assert_send = 0;
+ pim_ifp->pim_ifstat_bsm_cfg_miss = 0;
+ pim_ifp->pim_ifstat_ucast_bsm_cfg_miss = 0;
+ pim_ifp->pim_ifstat_bsm_invalid_sz = 0;
+ pim_ifp->igmp_ifstat_joins_sent = 0;
+ pim_ifp->igmp_ifstat_joins_failed = 0;
+ pim_ifp->igmp_peak_group_count = 0;
+}
+
+void pim_sock_reset(struct interface *ifp)
+{
+ struct pim_interface *pim_ifp;
+
+ assert(ifp);
+ assert(ifp->info);
+
+ pim_ifp = ifp->info;
+
+ pim_ifp->primary_address = pim_find_primary_addr(ifp);
+
+ pim_ifp->pim_sock_fd = -1;
+ pim_ifp->pim_sock_creation = 0;
+ pim_ifp->t_pim_sock_read = NULL;
+
+ pim_ifp->t_pim_hello_timer = NULL;
+ pim_ifp->pim_hello_period = PIM_DEFAULT_HELLO_PERIOD;
+ pim_ifp->pim_default_holdtime =
+ -1; /* unset: means 3.5 * pim_hello_period */
+ pim_ifp->pim_triggered_hello_delay = PIM_DEFAULT_TRIGGERED_HELLO_DELAY;
+ pim_ifp->pim_dr_priority = PIM_DEFAULT_DR_PRIORITY;
+ pim_ifp->pim_propagation_delay_msec =
+ PIM_DEFAULT_PROPAGATION_DELAY_MSEC;
+ pim_ifp->pim_override_interval_msec =
+ PIM_DEFAULT_OVERRIDE_INTERVAL_MSEC;
+ pim_ifp->pim_can_disable_join_suppression =
+ PIM_DEFAULT_CAN_DISABLE_JOIN_SUPPRESSION;
+
+ /* neighbors without lan_delay */
+ pim_ifp->pim_number_of_nonlandelay_neighbors = 0;
+ pim_ifp->pim_neighbors_highest_propagation_delay_msec = 0;
+ pim_ifp->pim_neighbors_highest_override_interval_msec = 0;
+
+ /* DR Election */
+ pim_ifp->pim_dr_election_last = 0; /* timestamp */
+ pim_ifp->pim_dr_election_count = 0;
+ pim_ifp->pim_dr_election_changes = 0;
+ pim_ifp->pim_dr_num_nondrpri_neighbors =
+ 0; /* neighbors without dr_pri */
+ pim_ifp->pim_dr_addr = pim_ifp->primary_address;
+ pim_ifp->am_i_dr = true;
+
+ pim_ifstat_reset(ifp);
+}
+
+#if PIM_IPV == 4
+static uint16_t ip_id = 0;
+#endif
+
+#if PIM_IPV == 4
+static int pim_msg_send_frame(int fd, char *buf, size_t len,
+ struct sockaddr *dst, size_t salen,
+ const char *ifname)
+{
+ if (sendto(fd, buf, len, MSG_DONTWAIT, dst, salen) >= 0)
+ return 0;
+
+ if (errno == EMSGSIZE) {
+ struct ip *ip = (struct ip *)buf;
+ size_t hdrsize = sizeof(struct ip);
+ size_t newlen1 = ((len - hdrsize) / 2) & 0xFFF8;
+ size_t sendlen = newlen1 + hdrsize;
+ size_t offset = ntohs(ip->ip_off);
+ int ret;
+
+ ip->ip_len = htons(sendlen);
+ ip->ip_off = htons(offset | IP_MF);
+
+ ret = pim_msg_send_frame(fd, buf, sendlen, dst, salen, ifname);
+ if (ret)
+ return ret;
+
+ struct ip *ip2 = (struct ip *)(buf + newlen1);
+ size_t newlen2 = len - sendlen;
+
+ sendlen = newlen2 + hdrsize;
+
+ memcpy(ip2, ip, hdrsize);
+ ip2->ip_len = htons(sendlen);
+ ip2->ip_off = htons(offset + (newlen1 >> 3));
+ return pim_msg_send_frame(fd, (char *)ip2, sendlen, dst, salen,
+ ifname);
+ }
+
+ zlog_warn(
+ "%s: sendto() failure to %pSU: iface=%s fd=%d msg_size=%zd: %m",
+ __func__, dst, ifname, fd, len);
+ return -1;
+}
+
+#else
+static int pim_msg_send_frame(pim_addr src, pim_addr dst, ifindex_t ifindex,
+ struct iovec *message, int fd)
+{
+ int retval;
+ struct msghdr smsghdr = {};
+ struct cmsghdr *scmsgp;
+ union cmsgbuf {
+ struct cmsghdr hdr;
+ uint8_t buf[CMSG_SPACE(sizeof(struct in6_pktinfo))];
+ };
+ struct in6_pktinfo *pktinfo;
+ struct sockaddr_in6 dst_sin6 = {};
+
+ union cmsgbuf cmsg_buf = {};
+
+ /* destination address */
+ dst_sin6.sin6_family = AF_INET6;
+#ifdef SIN6_LEN
+ dst_sin6.sin6_len = sizeof(struct sockaddr_in6);
+#endif /*SIN6_LEN*/
+ dst_sin6.sin6_addr = dst;
+ dst_sin6.sin6_scope_id = ifindex;
+
+ /* send msg hdr */
+ smsghdr.msg_iov = message;
+ smsghdr.msg_iovlen = 1;
+ smsghdr.msg_name = (caddr_t)&dst_sin6;
+ smsghdr.msg_namelen = sizeof(dst_sin6);
+ smsghdr.msg_control = (caddr_t)&cmsg_buf.buf;
+ smsghdr.msg_controllen = CMSG_SPACE(sizeof(struct in6_pktinfo));
+ smsghdr.msg_flags = 0;
+
+ scmsgp = CMSG_FIRSTHDR(&smsghdr);
+ scmsgp->cmsg_level = IPPROTO_IPV6;
+ scmsgp->cmsg_type = IPV6_PKTINFO;
+ scmsgp->cmsg_len = CMSG_LEN(sizeof(struct in6_pktinfo));
+
+ pktinfo = (struct in6_pktinfo *)(CMSG_DATA(scmsgp));
+ pktinfo->ipi6_ifindex = ifindex;
+ pktinfo->ipi6_addr = src;
+
+ retval = sendmsg(fd, &smsghdr, 0);
+ if (retval < 0)
+ flog_err(
+ EC_LIB_SOCKET,
+ "sendmsg failed: source: %pI6 Dest: %pI6 ifindex: %d: %s (%d)",
+ &src, &dst, ifindex, safe_strerror(errno), errno);
+
+ return retval;
+}
+#endif
+
+int pim_msg_send(int fd, pim_addr src, pim_addr dst, uint8_t *pim_msg,
+ int pim_msg_size, struct interface *ifp)
+{
+ struct pim_interface *pim_ifp;
+
+
+ pim_ifp = ifp->info;
+
+ if (pim_ifp->pim_passive_enable) {
+ if (PIM_DEBUG_PIM_PACKETS)
+ zlog_debug(
+ "skip sending PIM message on passive interface %s",
+ ifp->name);
+ return 0;
+ }
+
+#if PIM_IPV == 4
+ uint8_t ttl;
+ struct pim_msg_header *header;
+ unsigned char buffer[10000];
+
+ memset(buffer, 0, 10000);
+
+ header = (struct pim_msg_header *)pim_msg;
+
+/*
+ * Omnios apparently doesn't have a #define for IP default
+ * ttl that is the same as all other platforms.
+ */
+#ifndef IPDEFTTL
+#define IPDEFTTL 64
+#endif
+ /* TTL for packets destine to ALL-PIM-ROUTERS is 1 */
+ switch (header->type) {
+ case PIM_MSG_TYPE_HELLO:
+ case PIM_MSG_TYPE_JOIN_PRUNE:
+ case PIM_MSG_TYPE_BOOTSTRAP:
+ case PIM_MSG_TYPE_ASSERT:
+ ttl = 1;
+ break;
+ case PIM_MSG_TYPE_REGISTER:
+ case PIM_MSG_TYPE_REG_STOP:
+ case PIM_MSG_TYPE_GRAFT:
+ case PIM_MSG_TYPE_GRAFT_ACK:
+ case PIM_MSG_TYPE_CANDIDATE:
+ ttl = IPDEFTTL;
+ break;
+ default:
+ ttl = MAXTTL;
+ break;
+ }
+
+ struct ip *ip = (struct ip *)buffer;
+ struct sockaddr_in to = {};
+ int sendlen = sizeof(*ip) + pim_msg_size;
+ socklen_t tolen;
+ unsigned char *msg_start;
+
+ ip->ip_id = htons(++ip_id);
+ ip->ip_hl = 5;
+ ip->ip_v = 4;
+ ip->ip_tos = IPTOS_PREC_INTERNETCONTROL;
+ ip->ip_p = PIM_IP_PROTO_PIM;
+ ip->ip_src = src;
+ ip->ip_dst = dst;
+ ip->ip_ttl = ttl;
+ ip->ip_len = htons(sendlen);
+
+ to.sin_family = AF_INET;
+ to.sin_addr = dst;
+ tolen = sizeof(to);
+
+ msg_start = buffer + sizeof(*ip);
+ memcpy(msg_start, pim_msg, pim_msg_size);
+
+ if (PIM_DEBUG_PIM_PACKETS)
+ zlog_debug("%s: to %pPA on %s: msg_size=%d checksum=%x",
+ __func__, &dst, ifp->name, pim_msg_size,
+ header->checksum);
+
+ if (PIM_DEBUG_PIM_PACKETDUMP_SEND) {
+ pim_pkt_dump(__func__, pim_msg, pim_msg_size);
+ }
+
+ pim_msg_send_frame(fd, (char *)buffer, sendlen, (struct sockaddr *)&to,
+ tolen, ifp->name);
+ return 0;
+
+#else
+ struct iovec iovector[2];
+
+ iovector[0].iov_base = pim_msg;
+ iovector[0].iov_len = pim_msg_size;
+
+ pim_msg_send_frame(src, dst, ifp->ifindex, &iovector[0], fd);
+
+ return 0;
+#endif
+}
+
+static int hello_send(struct interface *ifp, uint16_t holdtime)
+{
+ uint8_t pim_msg[PIM_PIM_BUFSIZE_WRITE];
+ struct pim_interface *pim_ifp;
+ int pim_tlv_size;
+ int pim_msg_size;
+
+ pim_ifp = ifp->info;
+
+ if (PIM_DEBUG_PIM_HELLO)
+ zlog_debug(
+ "%s: to %pPA on %s: holdt=%u prop_d=%u overr_i=%u dis_join_supp=%d dr_prio=%u gen_id=%08x addrs=%d",
+ __func__, &qpim_all_pim_routers_addr, ifp->name,
+ holdtime, pim_ifp->pim_propagation_delay_msec,
+ pim_ifp->pim_override_interval_msec,
+ pim_ifp->pim_can_disable_join_suppression,
+ pim_ifp->pim_dr_priority, pim_ifp->pim_generation_id,
+ listcount(ifp->connected));
+
+ pim_tlv_size = pim_hello_build_tlv(
+ ifp, pim_msg + PIM_PIM_MIN_LEN,
+ sizeof(pim_msg) - PIM_PIM_MIN_LEN, holdtime,
+ pim_ifp->pim_dr_priority, pim_ifp->pim_generation_id,
+ pim_ifp->pim_propagation_delay_msec,
+ pim_ifp->pim_override_interval_msec,
+ pim_ifp->pim_can_disable_join_suppression);
+ if (pim_tlv_size < 0) {
+ return -1;
+ }
+
+ pim_msg_size = pim_tlv_size + PIM_PIM_MIN_LEN;
+
+ assert(pim_msg_size >= PIM_PIM_MIN_LEN);
+ assert(pim_msg_size <= PIM_PIM_BUFSIZE_WRITE);
+
+ pim_msg_build_header(pim_ifp->primary_address,
+ qpim_all_pim_routers_addr, pim_msg, pim_msg_size,
+ PIM_MSG_TYPE_HELLO, false);
+
+ if (pim_msg_send(pim_ifp->pim_sock_fd, pim_ifp->primary_address,
+ qpim_all_pim_routers_addr, pim_msg, pim_msg_size,
+ ifp)) {
+ if (PIM_DEBUG_PIM_HELLO) {
+ zlog_debug(
+ "%s: could not send PIM message on interface %s",
+ __func__, ifp->name);
+ }
+ return -2;
+ }
+
+ return 0;
+}
+
+int pim_hello_send(struct interface *ifp, uint16_t holdtime)
+{
+ struct pim_interface *pim_ifp = ifp->info;
+
+ if (if_is_loopback(ifp))
+ return 0;
+
+ if (hello_send(ifp, holdtime)) {
+ ++pim_ifp->pim_ifstat_hello_sendfail;
+
+ if (PIM_DEBUG_PIM_HELLO) {
+ zlog_warn("Could not send PIM hello on interface %s",
+ ifp->name);
+ }
+ return -1;
+ }
+
+ if (!pim_ifp->pim_passive_enable) {
+ ++pim_ifp->pim_ifstat_hello_sent;
+ PIM_IF_FLAG_SET_HELLO_SENT(pim_ifp->flags);
+ }
+
+ return 0;
+}
+
+static void hello_resched(struct interface *ifp)
+{
+ struct pim_interface *pim_ifp;
+
+ pim_ifp = ifp->info;
+
+ if (PIM_DEBUG_PIM_HELLO) {
+ zlog_debug("Rescheduling %d sec hello on interface %s",
+ pim_ifp->pim_hello_period, ifp->name);
+ }
+ EVENT_OFF(pim_ifp->t_pim_hello_timer);
+ event_add_timer(router->master, on_pim_hello_send, ifp,
+ pim_ifp->pim_hello_period, &pim_ifp->t_pim_hello_timer);
+}
+
+/*
+ Periodic hello timer
+ */
+static void on_pim_hello_send(struct event *t)
+{
+ struct pim_interface *pim_ifp;
+ struct interface *ifp;
+
+ ifp = EVENT_ARG(t);
+ pim_ifp = ifp->info;
+
+ /*
+ * Schedule next hello
+ */
+ hello_resched(ifp);
+
+ /*
+ * Send hello
+ */
+ pim_hello_send(ifp, PIM_IF_DEFAULT_HOLDTIME(pim_ifp));
+}
+
+/*
+ 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_restart_now(struct interface *ifp)
+{
+ struct pim_interface *pim_ifp;
+
+ pim_ifp = ifp->info;
+
+ /*
+ * Reset next hello timer
+ */
+ hello_resched(ifp);
+
+ /*
+ * Immediately send hello
+ */
+ pim_hello_send(ifp, PIM_IF_DEFAULT_HOLDTIME(pim_ifp));
+}
+
+/*
+ RFC 4601: 4.3.1. Sending Hello Messages
+
+ To allow new or rebooting routers to learn of PIM neighbors quickly,
+ when a Hello message is received from a new neighbor, or a Hello
+ message with a new GenID is received from an existing neighbor, a
+ new Hello message should be sent on this interface after a
+ randomized delay between 0 and Triggered_Hello_Delay.
+ */
+void pim_hello_restart_triggered(struct interface *ifp)
+{
+ struct pim_interface *pim_ifp;
+ int triggered_hello_delay_msec;
+ int random_msec;
+
+ pim_ifp = ifp->info;
+
+ /*
+ * No need to ever start loopback or vrf device hello's
+ */
+ if (if_is_loopback(ifp))
+ return;
+
+ /*
+ * There exists situations where we have the a RPF out this
+ * interface, but we haven't formed a neighbor yet. This
+ * happens especially during interface flaps. While
+ * we would like to handle this more gracefully in other
+ * parts of the code. In order to get us up and running
+ * let's just send the hello immediate'ish
+ * This should be revisited when we get nexthop tracking
+ * in and when we have a better handle on safely
+ * handling the rpf information for upstreams that
+ * we cannot legally reach yet.
+ */
+ triggered_hello_delay_msec = 1;
+ // triggered_hello_delay_msec = 1000 *
+ // pim_ifp->pim_triggered_hello_delay;
+
+ if (pim_ifp->t_pim_hello_timer) {
+ long remain_msec =
+ pim_time_timer_remain_msec(pim_ifp->t_pim_hello_timer);
+ if (remain_msec <= triggered_hello_delay_msec) {
+ /* Rescheduling hello would increase the delay, then
+ it's faster
+ to just wait for the scheduled periodic hello. */
+ return;
+ }
+
+ EVENT_OFF(pim_ifp->t_pim_hello_timer);
+ }
+
+ random_msec = triggered_hello_delay_msec;
+ // random_msec = random() % (triggered_hello_delay_msec + 1);
+
+ if (PIM_DEBUG_PIM_HELLO) {
+ zlog_debug("Scheduling %d msec triggered hello on interface %s",
+ random_msec, ifp->name);
+ }
+
+ event_add_timer_msec(router->master, on_pim_hello_send, ifp,
+ random_msec, &pim_ifp->t_pim_hello_timer);
+}
+
+int pim_sock_add(struct interface *ifp)
+{
+ struct pim_interface *pim_ifp;
+ uint32_t old_genid;
+
+ pim_ifp = ifp->info;
+ assert(pim_ifp);
+
+ if (pim_ifp->pim_sock_fd >= 0) {
+ if (PIM_DEBUG_PIM_PACKETS)
+ zlog_debug(
+ "Can't recreate existing PIM socket fd=%d for interface %s",
+ pim_ifp->pim_sock_fd, ifp->name);
+ return -1;
+ }
+
+ pim_ifp->pim_sock_fd = pim_sock_open(ifp);
+ if (pim_ifp->pim_sock_fd < 0) {
+ if (PIM_DEBUG_PIM_PACKETS)
+ zlog_debug("Could not open PIM socket on interface %s",
+ ifp->name);
+ return -2;
+ }
+
+ pim_socket_ip_hdr(pim_ifp->pim_sock_fd);
+
+ pim_ifp->t_pim_sock_read = NULL;
+ pim_ifp->pim_sock_creation = pim_time_monotonic_sec();
+
+ /*
+ * Just ensure that the new generation id
+ * actually chooses something different.
+ * Actually ran across a case where this
+ * happened, pre-switch to random().
+ * While this is unlikely to happen now
+ * let's make sure it doesn't.
+ */
+ old_genid = pim_ifp->pim_generation_id;
+
+ while (old_genid == pim_ifp->pim_generation_id)
+ pim_ifp->pim_generation_id = frr_weak_random();
+
+ zlog_info("PIM INTERFACE UP: on interface %s ifindex=%d", ifp->name,
+ ifp->ifindex);
+
+ /*
+ * Start receiving PIM messages
+ */
+ pim_sock_read_on(ifp);
+
+ /*
+ * Start sending PIM hello's
+ */
+ pim_hello_restart_triggered(ifp);
+
+ return 0;
+}