proxmox-mirrors/mirror_frr
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_frr synced 2025-11-04 13:22:24 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
759927a1b9
mirror_frr/pimd/pim_pim.c
Quentin Young ffa2c8986d *: remove THREAD_ON macros, add nullity check 
The way thread.c is written, a caller who wishes to be able to cancel a
thread or avoid scheduling it twice must keep a reference to the thread.
Typically this is done with a long lived pointer whose value is checked
for null in order to know if the thread is currently scheduled.  The
check-and-schedule idiom is so common that several wrapper macros in
thread.h existed solely to provide it.

This patch removes those macros and adds a new parameter to all
thread_add_* functions which is a pointer to the struct thread * to
store the result of a scheduling call. If the value passed is non-null,
the thread will only be scheduled if the value is null. This helps with
consistency.

A Coccinelle spatch has been used to transform code of the form:

  if (t == NULL)
    t = thread_add_* (...)

to the form

  thread_add_* (..., &t)

The THREAD_ON macros have also been transformed to the underlying
thread.c calls.

Signed-off-by: Quentin Young <qlyoung@cumulusnetworks.com>
2017-05-09 20:44:19 +00:00

876 lines
23 KiB
C
Raw Blame History

/*
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 "thread.h"
#include "memory.h"
#include "if.h"
#include "pimd.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"
static int on_pim_hello_send(struct thread *t);
static int pim_hello_send(struct interface *ifp,
uint16_t holdtime);
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);
}
}
THREAD_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);
}
}
THREAD_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) {
zlog_err("%s: %s: but PIM not enabled on interface %s (!)",
__PRETTY_FUNCTION__, 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);
}
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[INET_ADDRSTRLEN];
char dst_str[INET_ADDRSTRLEN];
uint8_t *pim_msg;
int pim_msg_len;
uint16_t pim_checksum; /* received checksum */
uint16_t checksum; /* computed checksum */
struct pim_neighbor *neigh;
struct pim_msg_header *header;
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_hdr = (struct ip *) buf;
ip_hlen = ip_hdr->ip_hl << 2; /* ip_hl gives length in 4-byte words */
pim_msg = buf + ip_hlen;
pim_msg_len = len - ip_hlen;
header = (struct pim_msg_header *)pim_msg;
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;
}
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;
if (header->type == PIM_MSG_TYPE_REGISTER)
{
/* First 8 byte header checksum */
checksum = in_cksum (pim_msg, PIM_MSG_REGISTER_LEN);
if (checksum != pim_checksum)
{
checksum = in_cksum (pim_msg, pim_msg_len);
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_cksum (pim_msg, pim_msg_len);
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) {
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));
zlog_debug("Recv PIM %s packet from %s to %s on %s: ttl=%d pim_version=%d pim_msg_size=%d checksum=%x",
pim_pim_msgtype2str (header->type), src_str, dst_str, ifp->name,
ip_hdr->ip_ttl, header->ver, pim_msg_len, checksum);
if (PIM_DEBUG_PIM_PACKETDUMP_RECV) {
pim_pkt_dump(__PRETTY_FUNCTION__, pim_msg, pim_msg_len);
}
}
switch (header->type)
{
case PIM_MSG_TYPE_HELLO:
return pim_hello_recv (ifp,
ip_hdr->ip_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,
ip_hdr->ip_dst,
ip_hdr->ip_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 (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, ip_hdr->ip_src);
if (!neigh) {
if (PIM_DEBUG_PIM_PACKETS)
zlog_debug("%s %s: non-hello PIM message type=%d from non-neighbor %s on %s",
__FILE__, __PRETTY_FUNCTION__,
header->type, src_str, ifp->name);
return -1;
}
pim_neighbor_timer_reset(neigh, neigh->holdtime);
return pim_joinprune_recv(ifp, neigh,
ip_hdr->ip_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, ip_hdr->ip_src);
if (!neigh) {
if (PIM_DEBUG_PIM_PACKETS)
zlog_debug("%s %s: non-hello PIM message type=%d from non-neighbor %s on %s",
__FILE__, __PRETTY_FUNCTION__,
header->type, src_str, ifp->name);
return -1;
}
pim_neighbor_timer_reset(neigh, neigh->holdtime);
return pim_assert_recv(ifp, neigh,
ip_hdr->ip_src,
pim_msg + PIM_MSG_HEADER_LEN,
pim_msg_len - PIM_MSG_HEADER_LEN);
break;
default:
if (PIM_DEBUG_PIM_PACKETS) {
zlog_debug("Recv PIM packet type %d which is not currently understood",
header->type);
}
return -1;
}
return -1;
}
static void pim_sock_read_on(struct interface *ifp);
static int pim_sock_read(struct thread *t)
{
struct interface *ifp;
struct pim_interface *pim_ifp;
int fd;
struct sockaddr_in from;
struct sockaddr_in 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;
ifp = THREAD_ARG(t);
fd = THREAD_FD(t);
pim_ifp = ifp->info;
while (cont)
{
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;
}
#ifdef PIM_CHECK_RECV_IFINDEX_SANITY
/* ifindex sanity check */
if (ifindex != (int) ifp->ifindex) {
char from_str[INET_ADDRSTRLEN];
char to_str[INET_ADDRSTRLEN];
struct interface *recv_ifp;
if (!inet_ntop(AF_INET, &from.sin_addr, from_str , sizeof(from_str)))
sprintf(from_str, "<from?>");
if (!inet_ntop(AF_INET, &to.sin_addr, to_str , sizeof(to_str)))
sprintf(to_str, "<to?>");
recv_ifp = if_lookup_by_index(ifindex, VRF_DEFAULT);
if (recv_ifp) {
zassert(ifindex == (int) recv_ifp->ifindex);
}
#ifdef PIM_REPORT_RECV_IFINDEX_MISMATCH
zlog_warn("Interface mismatch: recv PIM pkt from %s to %s on fd=%d: recv_ifindex=%d (%s) sock_ifindex=%d (%s)",
from_str, to_str, fd,
ifindex, recv_ifp ? recv_ifp->name : "<if-notfound>",
ifp->ifindex, ifp->name);
#endif
goto done;
}
#endif
int fail = pim_pim_packet(ifp, buf, len);
if (fail) {
if (PIM_DEBUG_PIM_PACKETS)
zlog_debug("%s: pim_pim_packet() return=%d",
__PRETTY_FUNCTION__, fail);
goto done;
}
count++;
if (count % qpim_packet_process == 0)
cont = 0;
}
result = 0; /* good */
done:
pim_sock_read_on(ifp);
if (result) {
++pim_ifp->pim_ifstat_hello_recvfail;
}
return result;
}
static void pim_sock_read_on(struct interface *ifp)
{
struct pim_interface *pim_ifp;
zassert(ifp);
zassert(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);
}
pim_ifp->t_pim_sock_read = NULL;
thread_add_read(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)) {
close(fd);
return -2;
}
return fd;
}
void pim_ifstat_reset(struct interface *ifp)
{
struct pim_interface *pim_ifp;
zassert(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;
}
void pim_sock_reset(struct interface *ifp)
{
struct pim_interface *pim_ifp;
zassert(ifp);
zassert(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;
if (PIM_DEFAULT_CAN_DISABLE_JOIN_SUPPRESSION) {
PIM_IF_DO_PIM_CAN_DISABLE_JOIN_SUPRESSION(pim_ifp->options);
}
else {
PIM_IF_DONT_PIM_CAN_DISABLE_JOIN_SUPRESSION(pim_ifp->options);
}
/* 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_ifstat_reset(ifp);
}
static uint16_t ip_id = 0;
static int
pim_msg_send_frame (int fd, char *buf, size_t len,
struct sockaddr *dst, size_t salen)
{
struct ip *ip = (struct ip *)buf;
while (sendto (fd, buf, len, MSG_DONTWAIT, dst, salen) < 0)
{
char dst_str[INET_ADDRSTRLEN];
switch (errno)
{
case EMSGSIZE:
{
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);
ip->ip_len = htons (sendlen);
ip->ip_off = htons (offset | IP_MF);
if (pim_msg_send_frame (fd, buf, sendlen, dst, salen) == 0)
{
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);
}
}
return -1;
break;
default:
if (PIM_DEBUG_PIM_PACKETS)
{
pim_inet4_dump ("<dst?>", ip->ip_dst, dst_str, sizeof (dst_str));
zlog_warn ("%s: sendto() failure to %s: fd=%d msg_size=%zd: errno=%d: %s",
__PRETTY_FUNCTION__,
dst_str, fd, len,
errno, safe_strerror(errno));
}
return -1;
break;
}
}
return 0;
}
int
pim_msg_send(int fd, struct in_addr src,
struct in_addr dst, uint8_t *pim_msg,
int pim_msg_size, const char *ifname)
{
struct sockaddr_in to;
socklen_t tolen;
unsigned char buffer[10000];
unsigned char *msg_start;
uint8_t ttl = MAXTTL;
struct pim_msg_header *header;
struct ip *ip;
memset (buffer, 0, 10000);
int sendlen = sizeof (struct ip) + pim_msg_size;
msg_start = buffer + sizeof (struct ip);
memcpy (msg_start, pim_msg, pim_msg_size);
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;
}
ip = (struct ip *) buffer;
ip->ip_id = htons (++ip_id);
ip->ip_hl = 5;
ip->ip_v = 4;
ip->ip_p = PIM_IP_PROTO_PIM;
ip->ip_src = src;
ip->ip_dst = dst;
ip->ip_ttl = ttl;
ip->ip_len = htons (sendlen);
if (PIM_DEBUG_PIM_PACKETS) {
struct pim_msg_header *header = (struct pim_msg_header *)pim_msg;
char dst_str[INET_ADDRSTRLEN];
pim_inet4_dump("<dst?>", dst, dst_str, sizeof(dst_str));
zlog_debug("%s: to %s on %s: msg_size=%d checksum=%x",
__PRETTY_FUNCTION__,
dst_str, ifname, pim_msg_size,
header->checksum);
}
memset(&to, 0, sizeof(to));
to.sin_family = AF_INET;
to.sin_addr = dst;
tolen = sizeof(to);
if (PIM_DEBUG_PIM_PACKETDUMP_SEND) {
pim_pkt_dump(__PRETTY_FUNCTION__, pim_msg, pim_msg_size);
}
pim_msg_send_frame (fd, (char *)buffer, sendlen,
(struct sockaddr *)&to, tolen);
return 0;
}
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) {
char dst_str[INET_ADDRSTRLEN];
pim_inet4_dump("<dst?>", qpim_all_pim_routers_addr, dst_str, sizeof(dst_str));
zlog_debug("%s: to %s on %s: holdt=%u prop_d=%u overr_i=%u dis_join_supp=%d dr_prio=%u gen_id=%08x addrs=%d",
__PRETTY_FUNCTION__,
dst_str, ifp->name,
holdtime,
pim_ifp->pim_propagation_delay_msec, pim_ifp->pim_override_interval_msec,
PIM_IF_TEST_PIM_CAN_DISABLE_JOIN_SUPRESSION(pim_ifp->options),
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_IF_TEST_PIM_CAN_DISABLE_JOIN_SUPRESSION(pim_ifp->options));
if (pim_tlv_size < 0) {
return -1;
}
pim_msg_size = pim_tlv_size + PIM_PIM_MIN_LEN;
zassert(pim_msg_size >= PIM_PIM_MIN_LEN);
zassert(pim_msg_size <= PIM_PIM_BUFSIZE_WRITE);
pim_msg_build_header(pim_msg, pim_msg_size, PIM_MSG_TYPE_HELLO);
if (pim_msg_send(pim_ifp->pim_sock_fd,
pim_ifp->primary_address,
qpim_all_pim_routers_addr,
pim_msg,
pim_msg_size,
ifp->name)) {
if (PIM_DEBUG_PIM_HELLO) {
zlog_debug("%s: could not send PIM message on interface %s",
__PRETTY_FUNCTION__, ifp->name);
}
return -2;
}
return 0;
}
static int pim_hello_send(struct interface *ifp,
uint16_t holdtime)
{
struct pim_interface *pim_ifp;
zassert(ifp);
pim_ifp = ifp->info;
zassert(pim_ifp);
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;
}
++pim_ifp->pim_ifstat_hello_sent;
return 0;
}
static void hello_resched(struct interface *ifp)
{
struct pim_interface *pim_ifp;
zassert(ifp);
pim_ifp = ifp->info;
zassert(pim_ifp);
if (PIM_DEBUG_PIM_HELLO) {
zlog_debug("Rescheduling %d sec hello on interface %s",
pim_ifp->pim_hello_period, ifp->name);
}
THREAD_OFF(pim_ifp->t_pim_hello_timer);
thread_add_timer(master, on_pim_hello_send, ifp, pim_ifp->pim_hello_period,
&pim_ifp->t_pim_hello_timer);
}
/*
Periodic hello timer
*/
static int on_pim_hello_send(struct thread *t)
{
struct pim_interface *pim_ifp;
struct interface *ifp;
ifp = THREAD_ARG(t);
pim_ifp = ifp->info;
/*
* Schedule next hello
*/
pim_ifp->t_pim_hello_timer = NULL;
hello_resched(ifp);
/*
* Send hello
*/
return 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;
zassert(ifp);
pim_ifp = ifp->info;
zassert(pim_ifp);
/*
* 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;
zassert(ifp);
pim_ifp = ifp->info;
zassert(pim_ifp);
/*
* 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;
}
THREAD_OFF(pim_ifp->t_pim_hello_timer);
pim_ifp->t_pim_hello_timer = NULL;
}
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);
}
thread_add_timer_msec(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;
zassert(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 = 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;
}
Reference in New Issue View Git Blame Copy Permalink