> Source: [sk117597](https://support.checkpoint.com/results/sk/sk117597)

# sk117597 - RouteD - PIM Informational and Error Messages

| Property | Value |
|----------|-------|
| Solution ID | sk117597 |
| Date Created | 2017-05-25 |
| Last Modified | 2017-09-19 |
| Technical Level | General |
| Products | Security Gateway |
| Versions | R82.10, R82, R81.20 |
| OS | Gaia |

## Solution

**This SecureKnowledge article is intended as a repository of the Gaia routing daemon (RouteD) PIM informational and error messages.**

**Background**

Dynamic Routing is fully integrated into the Gaia WebUI and command-line shell. BGP, OSPF and RIP are supported.

Dynamic Multicast Routing is supported, using PIM (Sparse Mode (SM), Dense Mode (DM) and Source-Specific Multicast (SSM)) and IGMP.

**Protocol-Independent Multicast (PIM)**- gets its name from the fact that it can work with any existing unicast protocol to perform multicast forwarding. PIM efficiently routes multicast traffic for groups that may span wide area (and inter-domain) networks. It works with all existing unicast routing protocols. PIM supports three modes: dense, sparse and Source-Specific Multicast (SSM). Only one mode of PIM can be enabled at a time.

For more detailed information, refer to Gaia Advanced Routing Administration Guide ([R77.X](http://downloads.checkpoint.com/dc/download.htm?ID=24803), [R80.10](http://downloads.checkpoint.com/dc/download.htm?ID=54803)).

**Important**

**These messages should be seen (either in */var/log/routed_messages* or */var/log/messages* ) and in */var/log/routed.log* on non-VSX machines.**

**On VSX machines these errors should be seen (either in */var/log/routed_messages_vs* or */var/log/messages* ) and in */var/log/routed_.log***

**Related Solutions:**

* [sk117598: RouteD - BGP Informational and Error Messages](https://supportcenter.checkpoint.com/supportcenter/portal?eventSubmit_doGoviewsolutiondetails=&solutionid=sk117598)
* [sk117599: RouteD - OSPF Informational and Error Messages](https://supportcenter.checkpoint.com/supportcenter/portal?eventSubmit_doGoviewsolutiondetails=&solutionid=sk117599)

|--------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Error Message Text                                                                                                       | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| pim_get_group_address: mismatch in address family xx                                                                     | The address family of the group (an IPv4 multicast destination) is a mismatch with the currently running PIM instance, which is running in IPv6 mode.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| PIM: pim_cluster_recv_stats: received global statistics while in master state                                            | This error message indicates that a cluster member tried to synchronize its protocol state with the cluster master. The PIM state engine should only be run and updated by the cluster master; cluster members should sync theirs with the master. This message could indicate that the cluster state has become unstable.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| PIM: pim_cluster_send_init_state: sending state for instance xx to member xx                                             | This informational message indicates that the *pim_cluster_send_init_state* routine was triggered. This is invoked to send the PIM state to a newly joining cluster member - you may infer that the node reporting this message is the cluster master.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| PIM: pim_cluster_sm_purge_igmp_orphans: purging sparse-mode IGMP orphan state                                            | This is an informational message which indicates the *pim_cluster_sm_purge_igmp_orphans* has triggered. The *pim_cluster_sm_purge_igmp_orphans* function is responsible for purging the Sparse Mode IGMP orphan states. An IGMP group is added to the orphan list when no action can be taken for it (e.g. the local node is the DR but no RP is known for the group).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| PIM: pim_cluster_purge_state: purging state of instance xx                                                               | This informational message shows that the cluster state is initializing and PIM is clearing its protocol state in preparation.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| PIM: pim_cluster_sm_purge_rp_state: purging sparse-mode (\*,\*,RP) state                                                 | This is an informational message which indicates the *pim_cluster_sm_purge_rp_state*has triggered. The *pim_cluster_sm_purge_rp_state* function is responsible for purging the Sparse Mode RP state.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| PIM: pim_cluster_sm_purge_activerpset: purging sparse-mode active RPset                                                  | This is an informational message which indicates the *pim_cluster_sm_purge_activerpset* has triggered. The *pim_cluster_sm_purge_activerpset* function is responsible for purging the Sparse Mode RP Set state.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| PIM: pim_cluster_sm_transition                                                                                           | This is an informational message which indicates the *pim_cluster_sm_transition* routine has triggered. The *pim_cluster_sm_transition* function handles changes between master to non-master state and vice-versa. * For sparse-mode, walk the ptree of 's in each instance and, * If this router is now the master, add oifs to any mfc decapsulated entries, or else delete mfc oif states for the corresponding entries. * Entries are stored in a ptree database; P-trees can handle frequent insertions and deletions with low maintenance overhead and small impact on search performance. The *oif* list of PIM is controlled by one of many factors depending on the protocol (dense/sparse/ssm) being used. These factors include presence of downstream receivers, join/prune messages received on an interface, etc. Events such as an *oif* going down, etc. cause triggered changes to the *oif* list. The outgoing interfaces list also evolves incrementally as and when we receive \<\*,g\> or join/prunes. Also, depending on the protocol both the entry and the specific *oif*are periodically timed-out. The *oif*list is initialized when the entry is created.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| PIM: pim_cluster_sm_send_sg_state: adding (s,g): src = xx, grp = xx to buffer                                            | This is an informational message which indicates the *pim_cluster_sm_send_sg_state* routine has triggered. This routine is called by the cluster master to send sparse-mode \<s,g\> state to a new cluster member. This message means that data is being buffered before getting sent to the member.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| PIM: pim_cluster_sm_send_sg_state: sent \<s,g\> state to member xx                                                       | This is an informational message which indicates the *pim_cluster_sm_send_sg_state* routine has triggered. This routine sends the sparse-mode state to a new cluster member. This message shows that the cluster master has sent its state to the cluster member.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| PIM: pim_cluster_sm_recv_instance_state: received PIM-SM instance state for instance xx                                  | This is an informational message which indicates the *pim_cluster_sm_recv_instance_state* routine has triggered. The *pim_cluster_sm_recv_instance_state* function is responsible for processing cluster PIM-SM sync messages, for instance state specifically, and adding the state to the local database.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| PIM: pim_cluster_sm_recv_sg: received sparse-mode (S,G) state                                                            | This is an informational message which indicates the *pim_cluster_sm_recv_sg* routine has triggered. The *pim_cluster_sm_recv_sg* function is responsible for processing cluster PIM-SM sync messages, for state entries specifically, and adding them to the local database.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| PIM: pim_cluster_sm_recv_sg: no pim state found on interface corresponding to address xx for iif for (s,g) (xx, xx)      | This is an error message which indicates the *pim_cluster_sm_recv_sg* routine has triggered, this routine receives and processes PIM-SM state information from the cluster master. The error happened because the local interface matching the *iif*, for a particular , which we received as part of a PIM-SM state sync download from the cluster master, does not have PIM-SM enabled. This error tells us that the PIM configurations between cluster master and member are not the same (but should be). The *iif* of a multicast route entry indicates the interface from which multicast data packets are accepted for forwarding. The *iif*is initialized when the entry is created.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| PIM: pim_cluster_sm_recv_rp_state: iif neighbor xx not found in iif for (\*,\*,xx)                                       | This is an error message which indicates the *pim_cluster_sm_recv_rp_state* routine has triggered, but the upstream neighbor address was not found in the local database. It may be advisable to restart the *ipsrd*, or reboot the local node to try and clear any corruption. The *pim_cluster_sm_recv_rp_state* function is responsible for processing cluster PIM-SM sync messages, for \<\*,\*,rp\> state entries specifically, and adding them to the local database.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| PIM: pim_cluster_sm_recv_rp_state: no local ifap found corresponding to address xx for iif for (\*,\*,A)                 | This is an error message which indicates the *pim_cluster_sm_recv_rp_state* routine has triggered. This routine receives and processes PIM-SM state information from the cluster master. This particular error shows us that for the RP referenced in the log message, there is no interface pointing upstream to the RP IP address. This could indicate a problem either with the local node's unicast routing table, or the interface state is inconsistent between the cluster master and cluster members.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| PIM pim_cluster_sm_recv_sg_state: pim is not enabled on oif with address xx for (s,g) (xx, xx)                           | This is an error message which indicates the *pim_cluster_sm_recv_sg_state* routine has triggered. This routine receives and processes PIM-SM state information from the cluster master. The error happened because the local interface matching an *oif*, for a particular \<s,g\>, which we received as part of a PIM-SM state sync download from the cluster master, does not have PIM-SM enabled. This error tells us that the PIM configurations between cluster master and member are not the same (but should be).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| PIM: pim_cluster_sm_send_sg_state: sending \<s,g\> state to member xx                                                    | This is an informational message which indicates the *pim_cluster_sm_send_sg_state* routine has triggered. This routine sends the sparse-mode state to a new cluster member. This message shows that the master is initiating a send to a cluster member.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| PIM: pim_cluster_sm_send_igmp_orphan_state: sent IGMP orphan state to member xx                                          | This is an informational message which indicates the *pim_cluster_sm_send_igmp_orphan_state* routine has triggered. This routine is called by the cluster master to send IGMP orphan state to a new cluster member. This message means that data has been sent to the member. IGMP is used between hosts and gateways on a single network to establish hosts' membership in particular multicast groups. The gateways use this information, in conjunction with a multicast routing protocol, to support IP multicasting across the Internet. A multicast router keeps a list of multicast group memberships for each attached network, and a timer for each membership.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| PIM: pim_cluster_sm_recv_activerpset_state: receiving active RPSet                                                       | This is an informational message which indicates the *pim_cluster_sm_recv_activerpset_state* routine has triggered. This routine receives and processes PIM-SM candidate-RP state information from the cluster master. In order to determine the RP for a multicast group, a PIM router maintains a collection of group-to-RP mappings, called the RP-Set. A group-to-RP mapping contains the following elements. * Multicast group range, expressed as an address and prefix length * RP priority * RP address * Hash mask length * SM / BIDIR flag There are a number of ways in which such group-to-RP mappings can be established. The simplest solution is for all the routers in the domain to be statically configured with the same information. The BSR mechanism provides a way in which viable group-to-RP mappings can be created and rapidly distributed to all the PIM routers in a domain. It is adaptive, in that if an RP becomes unreachable, this will be detected and the RP-Sets will be modified so that the unreachable RP is no longer used. The general idea behind the BSR mechanism is that some of the PIM routers within a PIM domain are configured to be potential RPs for the domain. These are known as Candidate-RPs (C-RPs). A subset of the C- RPs will eventually be used as the actual RPs for the domain. In addition, some of the PIM routers in the domain are configured to be candidate bootstrap routers, or Candidate-BSRs (C-BSRs). One of these C-BSRs will be elected to be the bootstrap router (BSR) for the domain, and all the PIM routers in the domain will learn the result of this election through Bootstrap messages. The C-RPs will then report their candidacy to the elected BSR, which chooses a subset of these C-RPs and distributes corresponding group-to-RP mappings to all the routers in the domain through Bootstrap messages.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| PIM: pim_cluster_sm_recv_activerpset_crp_state: failed to add crp to active rpset xxxx                                   | This is an error message which indicates the *pim_cluster_sm_recv_activerpset_state* routine has triggered. This routine receives and processes PIM-SM candidate-RP state information from the cluster master. This specific error message shows that the routine tried to add a Candidate-RP to the local node's database, but was unsuccessful. The simplest way to diagnose a corrupt local PIM state database, is to reboot, or kill *ipsrd*(it will be restarted by the process manager).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| PIM: pim_cluster_sm_recv_sg_state: no \<\*,\*,xx\> found in local database for (xx, xx)                                  | This is an error message which indicates the *pim_cluster_sm_recv_sg_state* routine has triggered, but that for the \<s,g\> entry, no corresponding RP exists in the local database. The *pim_cluster_sm_recv_sg_state* function is responsible for processing cluster PIM-SM sync messages, for \<s,g\> state entries specifically, and adding them to the local database. Rendezvous Point (RP). Each multicast group has a shared-tree via which receivers hear of sources. The RP is the root of this per-group shared tree, called the RP-Tree. Candidate-RPs are routers configured to participate as RPs for some (or all) groups.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| PIM: pim_cluster_sm_recv_rp_state: no local ifap found corresponding to address xx for iif for \<\*,\*,A\>               | This is an error message which indicates the *pim_cluster_sm_recv_rp_state* routine has triggered, but no local interface corresponding to the *iif* was found. There may have been some recent interface or routing changes which are triggering this error. The *pim_cluster_sm_recv_rp_state* function is responsible for processing cluster PIM-SM sync messages, for \<\*,\*,rp\> state entries specifically, and adding them to the local database.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| PIM: pim_cluster_sm_recv_igmp_orphan_state: received igmp orphan state for existing group xx for oif xx                  | This is an error message which indicates the *pim_cluster_sm_recv_igmp_orphan_state* routine has triggered. This routine receives and processes IGMP orphan state information from the cluster master. This particular error shows us that for an IGMP membership state entry, there is an active group state entry. This inconsistency should not occur, as the cluster master and member should have the same state entries. Try restarting *ipsrd*, or rebooting.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| PIM: pim_cluster_dm_recv_sg: no pim state found on interface corresponding to address xx for iif for (S,G) (xx, xx)      | This is an error message which indicates the *pim_cluster_dm_recv_sg* routine has triggered, but the PIM state on an interface on a cluster member is not enabled. This error message could indicate that the cluster is misconfigured (for example, the interfaces on cluster members do not match each other), or an interface is down or has been removed, has had PIM disabled, or never enabled. The *pim_cluster_dm_recv_sg* function takes a received DM \<s,g\> message and creates/deletes an \<s,g\> entry. Unless the entry is being added during initial state download, it is accepted only if a local unicast route exists for the source and the *iif* matches the *iif* sent in the update.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| PIM: pim_cluster_dm_recv_sg: ignoring delete request for (xx, xx): no corresponding local entry                          | This is a warning message which indicates the *pim_cluster_dm_recv_sg* routine has triggered, but that there is no local \<s,g\> entry matching the delete request.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| PIM: pim_cluster_dm_recv_sg: no pim state found on interface corresponding to address xx when processing a pim_dm_sgif_r | This is an error message which indicates the *pim_cluster_dm_recv_if_timer_list* routine has triggered, and that there was no interface found locally that has PIM enabled, which matches the MFC \<s,g\> entry which was received from the cluster master. This is likely due to a mismatched PIM interface configuration, between cluster master and member.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| im_cluster_dm_recv_sg: no pim state found on interface corresponding to address xx for oif for (S,G) (xx, xx)            | This is an error message which indicates the *pim_cluster_dm_recv_sg* routine has triggered, but that the downstream PIM neighbor is unreachable due to PIM not being enabled on the *oif*which matches the MFC \<s,g\> entry. This may have been caused by an interface having had its PIM state disabled between the time an \<s,g\> MFC entry was created, and now - when the entry was created the *oif*list for the \<s,g\> entry was correct.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| PIM: pim_cluster_dm_recv_pkt_msg: received packet message of type xx                                                     | This is an informational message which indicates the *pim_cluster_dm_recv_pkt_msg* routine has triggered. The *pim_cluster_dm_recv_pkt_msg* function processes PIM packets that a member wants the master to send out on its behalf, which the master would not otherwise send out. Routing protocol states are propogated from cluster master to cluster members to allow the rapid failover from master to member in the event the master becomes unavailable. Routing protocols are managed solely by the cluster master, the members act in a "passive" role in standby, to take over if necessary. The propogation of cluster routing protocol states is done over the cluster sync interface.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| PIM: pim_cluster_dm_send_pkt_msg: sending pkt message of type xx to master                                               | This is an informational message which indicates the *pim_cluster_dm_send_pkt_msg* routine is running. This function is called on a member to send a Graft/Join/Assert/Prune that this node wants the master to send out on its behalf. Such a packet would not ordinarily be sent out by the master.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| PIM: pim_cluster_dm_send_sg: sending (S,G) state for (xx, xx) to member xx                                               | This is an informational message which indicates the *pim_cluster_dm_send_sg* routine is running. This function sends out one entry per packet, from the cluster master to cluster members.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| PIM: pim_cluster_dm_send_init_state: sending initial dense-mode state to member xx                                       | This informational message indicates that the cluster master, which is running PIM Dense Mode, is sending its PIM routing protocol state to a cluster member.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| PIM: pim_cluster_dm_propagate_sg_in_cluster: sending (S,G) state for (xx, xx) to all cluster members                     | This is an informational message which indicates the *pim_cluster_dm_propagate_sg_in_cluster* routine is running. This function is called on a node on which a local has been added or deleted. The intent of this function is to propagate state about the added/deleted entry in the cluster, so that other cluster members are updated with this info.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| PIM: pim_cluster_recv_nbrstate: received neighbor state message while in master state                                    | This error message indicates that a cluster member tried to synchronize its protocol state with the cluster master. This would happen if the member also believes that it is the cluster master. This could indicate that the cluster state has become unstable.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| PIM: pim_cluster_recv_nbrstate: received state for neighbor xx that already exists                                       | This error message indicates that a cluster member tried to synchronize its protocol state with the cluster master, but that the neighbor state already exists in the local Neighbor State table, and would appear to be a duplicate or redundant message. The PIM state engine holds generic (non-\<\*,\*,\*\>) information such as Neighbor State. Neighbor State: (for each neighbor) * Information from neighbor's Hello * Neighbor's GenID. * Neighbor Liveness Timer (NLT)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| PIM: pim_cluster_recv_ifstate: no pim state found on interface corresponding to address xx                               | This error message indicates that a cluster member tried to synchronize its protocol state with the cluster master, but that an interface on which the cluster master has PIM enabled, does not match a local cluster member interface's PIM-enabled status. All cluster nodes should have identical interface/routing protocol configurations.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| PIM: pim_cluster_instace_state: received instance-specific state while in master state                                   | This error message indicates that a cluster member tried to synchronize its protocol state with the cluster master. This would happen if the member also believes that it is the cluster master. This could indicate that the cluster state has become unstable.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| pim_dm_assert_timeout: timer fired                                                                                       | This is an informational message which indicates the *pim_dm_assert_timeout* routine has triggered. This routine is responsible for refreshing the RPF information for the PIM-DM \<s,g\> state entries. The PIM Assert mechanism is used to suppress duplicate flows onto the same multi-access network. When two routers both forward the same (S, G) multicast traffic onto a common multi-access LAN, Assert messages are generated by both routers to determine which router should continue forwarding on the LAN and which router(s) should stop (prune) for a specific timeout. PIM assert mechanism uses the following logic to elect the assert winner: <br /> * If the same routing protocol is used between the redundant neighbors, the metric is compared and the best metric wins. * In the case of an equal cost metric with the same routing protocol - the highest IP address neighbor will break the tie. * In the case where dissimilar unicast routing protocols are used, a metric preference is used to weight the preferred order of the routing information of each unicast routing protocol (like administrative distance) ``` ��������������������� Assert Message Format ��� 0������������������ 1������������������ 2������������������ 3 ��� 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 �� +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ �� |PIM Ver| Type� |�� Reserved��� |���������� Checksum����������� | �� +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ �� |������������� Group Address (Encoded-Group format)������������ | �� +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ �� |����������� Source Address (Encoded-Unicast format)����������� | �� +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ �� |R|��������������������� Metric Preference��������������������� | �� +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ �� |���������������������������� Metric��������������������������� | �� +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| pim_dm_send_assert: error while sending assert for group xx,xx/xx out input interface xx                                 | This is an informational message which indicates the *pim_dm_send_assert* routine has triggered, but an unspecified error has stopped the local node from sending out an Assert packet.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| pim_dm_stop_pkts: Internal inconsistency for output interface                                                            | This is an error message which indicates the *pim_dm_stop_pkts* routine has triggered. This routine is responsible for stopping the flow of packets out of an interface, and ensuring that the PIM-DM interface record for an *oif* is valid before removing it from the \<\*,g\> *oif* list. If it is not, this error will be shown. This could indicate an interface state change. Restarting *ipsrd,*or rebooting is a valid troubleshooting step.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| pim_dm_fwd_pkts: forwarding packets for group xx,xx/xx out interface xx                                                  | This is an informational message which indicates the *pim_dm_fwd_pkts* routine has triggered. This routine is responsible for adding an interface to the *oif* list of an entry, and ensuring that the PIM-DM interface record for an *oif* is valid before adding it to the \<\*,g\> *oif* list. This message shows us that the *oif*was added to the PIM-DM entry.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| pim ASSERT received for group xx,xx/xx on interface xx                                                                   | This is an informational message which indicates the *pim_dm_recv_assert* routine has triggered. This routine is responsible for processing a received Assert message from a downstream router.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| pim GRAFT ACK received for group xx,xx/xx on interface xx\\n                                                             | This is an informational message which indicates the *pim_dm_recv_graftAck* routine has triggered. The routine handles a single received Graft-Ack. ``` ��������������������� Join/Prune Message ``` ``` �0������������������ 1������������������ 2������������������ 3 �0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 �+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ �|PIM Ver| Type� | Reserved����� |���������� Checksum����������� | �+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ �|������������ Encoded-Unicast-Upstream Neighbor Address�������� | �+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ �|� Reserved���� | Num groups��� |��������� Holdtime������������ | �+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ �|����������� Encoded-Multicast Group Address-1����������������� | �+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ �|�� Number of Joined� Sources�� |�� Number of Pruned Sources��� | �+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ �|�������������� Encoded-Joined Source Address-1���������������� | �+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ �|���������������������������� .�������������������������������� | �|���������������������������� .�������������������������������� | �+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ �|�������������� Encoded-Joined Source Address-n���������������� | �+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ �|�������������� Encoded-Pruned Source Address-1���������������� | �+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ �|���������������������������� .�������������������������������� | �|���������������������������� .�������������������������������� | �+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ �|�������������� Encoded-Pruned Source Address-n���������������� | �+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ �|�������������������������� .���������������������������������� | �|�������������������������� .���������������������������������� | �|�������������������������� .���������������������������������� | �+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ �|��������������� Encoded-Multicast Group Address-n������������� | �+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ �|�� Number of Joined� Sources�� |�� Number of Pruned Sources��� | �+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ``` PIM Graft messages use the same format as Join/Prune messages, except that the Type field is set to 6. PIM Graft messages are used to reduce the join latency when a previously pruned branch of the Source Tree must be �grafted� back. This can be the case when a member joins the group after the router has sent a Prune message to prune off unwanted traffic. If Grafts were not used, the member would have to wait up to three minutes for the periodic re-flooding to occur to begin receiving the multicast traffic. By using Grafts, the Prune can be reversed almost immediately. Grafts are the only PIM messages that are sent reliably; they get a Graft-Ack acknowledgement. When the upstream router receives the Graft message, it adds the interface on which the message was received to its outgoing interface list. The interface is put into forward state, and a Graft Ack message is immediately unicast to the new downstream neighbor. If the router is already forwarding packets to other downstream neighbors, nothing else must be done. If the router has also pruned itself from the tree, however, it too must send a Graft to its upstream neighbor. When a router sends a Graft message, it waits 3 seconds for a Graft-Ack. If the acknowledgement is not received within that time, the router retransmits the Graft message. |
| pim_dm_graft_repeat_timeout: timer fired                                                                                 | This is an informational message which indicates the *pim_dm_graft_repeat_timeout*routine has triggered. The routine is a timer and repeats Graft messages until the Graft-Ack returns.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| pim_dm_mfc_graft: No such group xx,xx/xx: ignoring MFC request to send graft                                             | This is an informational message which indicates the *pim_dm_mfc_graft* routine has triggered. This routine handles MFC calls to the PIM-DM processes, to handle grafts. This message shows that a graft request was received, but the group does not exist in the multicast distribution tree. In such case, the graft request is ingored. PIM-Graft Messages are sent by a downstream router to a neighboring upstream router to reinstate a previously pruned branch of a source tree. The format is the same as a Join/Prune message, except that the value in the type field is 6. The Multicast Forwarding Cache (MFC) consists basically of the source address \<s,\*\>, group address \<\*,g\>, an incoming interface (*iif* ), and an outgoing interface list (*oiflist*).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| pim PRUNE received for xx on interface xx                                                                                | This is an informational message which indicates the *pim_dm_recv_prune* routine has triggered. The routine handles a single received Prune request.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| pim_dm_prune_delay_timeout: timer fired                                                                                  | This is an informational message which indicates the *pim_dm_prune_delay_timeout* routine has triggered, this routine is responsible for waiting for the Prune delay holdtime to expire. It then looks for output interfaces which are now ready to be pruned after having waited for Prune-overrides. When a source first starts sending data, each router on the source's LAN receives the data and forwards it to all its PIM neighbors and to all links with directly attached receivers for the data. Each router that receives a forwarded packet also forwards it likewise. Some routers will have no need of the data, either for directly connected receivers or for other PIM neighbors. These routers respond to receipt of the data by sending a PIM Prune message upstream, which instantiates Prune state in the upstream router, causing it to stop forwarding the data to its downstream neighbor. Eventually, the Prune state at each router will time out, and data will begin to flow back into the parts of the network that were previously pruned. This will trigger further Prune messages to be sent, and the Prune state will be instantiated once more.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| pim_dm_fwd_pkts: Missing output interface for group xx,xx/xx                                                             | This is an error message which indicates the *pim_dm_stop_pkts* routine has triggered. This routine is responsible for stopping the flow of packets out of an interface, and ensuring that the PIM-DM interface record for an *oif* is valid before removing it from the \<\*,g\> *oif* list. If it's not, this error will be shown. This could indicate an interface state change. Restarting *ipsrd* or rebooting is a valid troubleshooting step.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |

---

# Agent Instructions

This content is from the Check Point Support Center (https://support.checkpoint.com), the official knowledge base for Check Point cybersecurity products.

## Navigating This Knowledge Base

- **Complete index**: [llms.txt](https://support.checkpoint.com/llms.txt)
- **All SK articles**: [SecureKnowledge Sitemap](https://support.checkpoint.com/sitemaps/secureknowledge-sitemap-index.xml)
- **SK article URL pattern**: `https://support.checkpoint.com/results/sk/{skId}`
- **Markdown responses**: AI bot User-Agents automatically receive `text/markdown` content
