/* packet-pim.c

 * Routines for PIM disassembly

 * (c) Copyright Jun-ichiro itojun Hagino <itojun@itojun.org>

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

 * SPDX-License-Identifier: GPL-2.0-or-later

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/prefs.h>

#include <epan/expert.h>

#include <epan/in_cksum.h>

#include <epan/to_str.h>

#include <epan/tfs.h>

#include <wsutil/array.h>

#include "packet-iana-data.h"

#include "packet-igmp.h"

void proto_register_pim(void);

void proto_reg_handoff_pim(void);

#define PIM_TYPE(x)             ((x) & 0x0f)

#define PIM_VER(x)              (((x) & 0xf0) >> 4)

#define PIM_BIDIR_SUBTYPE(x)    ((x) & 0x0f)

#define PIM_SUBTYPE(x)          (((x) & 0xf0) >> 4)

/* PIM message type */

#define PIM_TYPE_HELLO 0            /* Hello [RFC3973][RFC4601] */

#define PIM_TYPE_REGISTER 1         /* Register [RFC4601] */

#define PIM_TYPE_REGISTER_STOP 2    /* Register Stop [RFC4601] */

#define PIM_TYPE_JOIN_PRUNE 3       /* Join/Prune [RFC3973][RFC4601] */

#define PIM_TYPE_BOOTSTRAP 4        /* Bootstrap [RFC4601] */

#define PIM_TYPE_ASSERT 5           /* Assert [RFC3973][RFC4601] */

#define PIM_TYPE_GRAFT 6            /* Graft [RFC3973] */

#define PIM_TYPE_GRAFT_ACK 7        /* Graft-Ack [RFC3973] */

#define PIM_TYPE_CAND_RP_ADV 8      /* Candidate RP Advertisement [RFC4601] */

#define PIM_TYPE_STATE_REFRESH 9    /* State Refresh [RFC3973] */

#define PIM_TYPE_DF_ELECT 10        /* DF Election [RFC5015] */

#define PIM_TYPE_ECMP_REDIR 11      /* ECMP Redirect [RFC6754] */

#define PIM_TYPE_PFM 12             /* PIM PFM [RFC8364] */

#define PIM_TYPE_PACKED_REGISTER 13 /* PIM PFM [RFC9465] */

/* PIM Message Subtypes */

#define PIM_TYPE_PACKED_NULL_REGISTER 0  /* 13.0 */

#define PIM_TYPE_PACKED_REGISTER_STOP 1  /* 13.1 */

/* PIM Message hello options */

#define PIM_HELLO_HOLD_T 1          /* Hold Time [RFC7761] */

#define PIM_HELLO_LAN_PRUNE_DELAY 2 /* LAN Prune Delay [RFC3973] */

#define PIM_HELLO_LABEL_PARA 17     /* Label Parameters [Dino_Farinacci] */

#define PIM_HELLO_DEPRECATED_18 18  /* Deprecated */

#define PIM_HELLO_DR_PRIORITY 19    /* DR Priority [RFC7761] */

#define PIM_HELLO_GEN_ID 20         /* Generation ID [RFC3973] */

#define PIM_HELLO_STATE_REFRESH 21  /* State-Refresh [RFC3973] */

#define PIM_HELLO_BIDIR_CAPA 22     /* Bidirectional Capable [RFC5015] */

#define PIM_HELLO_VCI_CAPA 23       /* VCI Capability */

#define PIM_HELLO_VAR_ADDR_LST 24   /* variable Address List [RF7761] */

#define PIM_HELLO_VAR_NEIG_LST 25   /* variable Neighbor List TLV */

#define PIM_HELL0_JOIN_ATTR 26      /* Join Attribute [RFC5384] */

#define PIM_HELLO_O_TCP_CAPA 27     /* variable PIM-over-TCP-Capable [RFC6559] */

#define PIM_HELLO_O_SCTP_CAPA 28    /* variable PIM-over-SCTP-Capable [RFC6559] */

#define PIM_HELLO_VAR_POP_COUNT 29  /* variable Pop-Count [RFC6807] */

#define PIM_HELLO_MT_ID 30          /* PIM MT-ID [RFC6420] */

#define PIM_HELLO_INT_ID 31         /* Interface ID [RFC6395] */

#define PIM_HELLO_ECMP_REDIR 32     /* PIM ECMP Redirect Hello Option [RFC6754] */

#define PIM_HELLO_VPC_PEER_ID 33    /* 2 vPC Peer ID */

#define PIM_HELLO_DR_LB_CAPA 34     /* variable DR Load Balancing Capability [RFC8775] */

#define PIM_HELLO_DR_LB_LIST 35     /* variable DR Load Balancing List [RFC8775] */

#define PIM_HELLO_HIER_JP_ATTR 36   /* Hierarchical Join/Prune Attribute [RFC7887] */

#define PIM_HELLO_ADDR_LST 65001    /* Address list, old implementation */

#define PIM_HELLO_RPF_PROXY 65004   /* RPF Proxy Vector (Cisco proprietary) */

/* PIM PFM message */

#define PIM_PFM_GROUP_SOURCE 1 /* Source Group Holdtime [RFC8364] */

/* PIM BIDIR DF election messages */

#define PIM_BDIR_DF_OFFER 1

#define PIM_BDIR_DF_WINNER 2

#define PIM_BDIR_DF_BACKOFF 3

#define PIM_BDIR_DF_PASS 4

/* PIM Address Encoding Types */

#define PIM_ADDR_ET_NATIVE    0  /* RFC7761 */

#define PIM_ADDR_ET_NATIVE_JA 1  /* RFC5384 */

#define PIM_TRANSPORT_MODE_MULTICAST 0           /*RFC8059*/

#define PIM_TRANSPORT_MODE_UNICAST_REPLICATION 1 /*RFC8059*/

#define PIM_JOIN_ATTRIBUTE_TYPE_RPF    0 /* RFC5496 */

#define PIM_JOIN_ATTRIBUTE_TYPE_MVPN   1 /* RFC6513 */

#define PIM_JOIN_ATTRIBUTE_TYPE_MTID   2 /* RFC6420 */

#define PIM_JOIN_ATTRIBUTE_TYPE_PC     3 /* RFC6807 */

#define PIM_JOIN_ATTRIBUTE_TYPE_EX_RPF 4 /* RFC7891 */

#define PIM_JOIN_ATTRIBUTE_TYPE_TA     5 /* RFC8059 */

#define PIM_JOIN_ATTRIBUTE_TYPE_RLOC   6 /* RFC8059 */

#define PIM_GROUP_ADDR_FLAGS_B        0x80

#define PIM_GROUP_ADDR_FLAGS_RESERVED 0x7E

#define PIM_GROUP_ADDR_FLAGS_Z        0x01

#define PIM_SOURCE_ADDR_FLAGS_RESERVED 0xF8

#define PIM_SOURCE_ADDR_FLAGS_S        0x04

#define PIM_SOURCE_ADDR_FLAGS_W        0x02

#define PIM_SOURCE_ADDR_FLAGS_R        0x01

#define PIM_SOURCE_JA_FLAGS_F         0x80

#define PIM_SOURCE_JA_FLAGS_E         0x40

#define PIM_SOURCE_JA_FLAGS_ATTR_TYPE 0x3F

static const value_string pimtypevals[] = {

    { PIM_TYPE_HELLO, "Hello" },

    { PIM_TYPE_REGISTER, "Register" },

    { PIM_TYPE_REGISTER_STOP, "Register-stop" },

    { PIM_TYPE_JOIN_PRUNE, "Join/Prune" },

    { PIM_TYPE_BOOTSTRAP, "Bootstrap" },

    { PIM_TYPE_ASSERT, "Assert" },

    { PIM_TYPE_GRAFT, "Graft" },

    { PIM_TYPE_GRAFT_ACK, "Graft-Ack" },

    { PIM_TYPE_CAND_RP_ADV, "Candidate-RP-Advertisement" },

    { PIM_TYPE_STATE_REFRESH, "State-Refresh" },

    { PIM_TYPE_DF_ELECT, "DF election"},

    { PIM_TYPE_ECMP_REDIR, "ECMP redirect" },

    { PIM_TYPE_PFM, "PFM source discovery"},

    { PIM_TYPE_PACKED_REGISTER, "Packed Register"},

    { 0, NULL }

};

/*

 * List of subtypes for PIM message Type 13.

 */

static const value_string pimtype13subtypevals[] = {

    { PIM_TYPE_PACKED_NULL_REGISTER, "Packed Null-Register" },

    { PIM_TYPE_PACKED_REGISTER_STOP, "Packed Register-Stop" },

    { 0, NULL }

};

static const value_string pimbdirdfvals[] = {

    { PIM_BDIR_DF_OFFER, "offer"},

    { PIM_BDIR_DF_WINNER, "DF Winner"},

    { PIM_BDIR_DF_BACKOFF, "DF Backoff"},

    { PIM_BDIR_DF_PASS, "DF Pass"},

    { 0, NULL }

};

static const value_string pim_opt_vals[] = {

    { PIM_HELLO_HOLD_T,          "Hold Time" },

    { PIM_HELLO_LAN_PRUNE_DELAY, "LAN Prune Delay" },

    { PIM_HELLO_LABEL_PARA,      "Label Parameters" },

    { PIM_HELLO_DEPRECATED_18,   "Deprecated" },

    { PIM_HELLO_DR_PRIORITY,     "DR Priority" },

    { PIM_HELLO_GEN_ID,          "Generation ID" },

    { PIM_HELLO_STATE_REFRESH,   "State-Refresh" },

    { PIM_HELLO_BIDIR_CAPA,      "Bidirectional Capable" },

    { PIM_HELLO_VCI_CAPA,        "VCI Capability" },

    { PIM_HELLO_VAR_ADDR_LST,    "Address List" },

    { PIM_HELLO_VAR_NEIG_LST,    "Neighbor List TLV" },

    { PIM_HELL0_JOIN_ATTR,       "Join Attribute" },

    { PIM_HELLO_O_TCP_CAPA,      "PIM-over-TCP-Capable" },

    { PIM_HELLO_O_SCTP_CAPA,     "PIM-over-SCTP-Capable" },

    { PIM_HELLO_VAR_POP_COUNT,   "Pop-Count" },

    { PIM_HELLO_MT_ID,           "PIM MT-ID" },

    { PIM_HELLO_INT_ID,          "Interface ID" },

    { PIM_HELLO_ECMP_REDIR,      "PIM ECMP Redirect Hello Option" },

    { PIM_HELLO_VPC_PEER_ID,     "vPC Peer ID" },

    { PIM_HELLO_DR_LB_CAPA,      "DR Load Balancing Capability" },

    { PIM_HELLO_DR_LB_LIST,      "DR Load Balancing List" },

    { PIM_HELLO_HIER_JP_ATTR,    "Hierarchical Join/Prune Attribute" },

    { PIM_HELLO_ADDR_LST,        "Address list, old implementation" },

    { PIM_HELLO_RPF_PROXY,       "RPF Proxy Vector (Cisco proprietary)" },

    { 0, NULL }

};

static const value_string pim_opt_vals1[] = {

    { PIM_PFM_GROUP_SOURCE,          "Group Source Holdtime TLV" },

    { 0, NULL }

};

static const value_string pim_addr_et_vals[] = {

    { PIM_ADDR_ET_NATIVE,    "Native"},

    { PIM_ADDR_ET_NATIVE_JA, "Native with Join Attribute"},

    { 0, NULL }

};

static const value_string attribute_transport_mode[] = {

    {PIM_TRANSPORT_MODE_UNICAST_REPLICATION, "Unicast Replication"},

    {PIM_TRANSPORT_MODE_MULTICAST, "Multicast"},

    {0, NULL}};

static const value_string pim_join_attribute_type_vals[] = {

    { PIM_JOIN_ATTRIBUTE_TYPE_RPF,    "RPF Vector TLV"},

    { PIM_JOIN_ATTRIBUTE_TYPE_MVPN,   "MVPN Join Attribute"},

    { PIM_JOIN_ATTRIBUTE_TYPE_MTID,   "MT-ID Join Attribute"},

    { PIM_JOIN_ATTRIBUTE_TYPE_PC,     "Pop-Count"},

    { PIM_JOIN_ATTRIBUTE_TYPE_EX_RPF, "Explicit RPF Vector"},

    { PIM_JOIN_ATTRIBUTE_TYPE_TA,     "Transport Attribute"},

    { PIM_JOIN_ATTRIBUTE_TYPE_RLOC,   "Receiver RLOC Attribute"},

    { 0, NULL }

};

enum pimv2_addrtype {

    pimv2_unicast, pimv2_group, pimv2_source

};

static int proto_pim;

static int hf_pim_version;

static int hf_pim_type;

static int hf_pim_code;

static int hf_pim_igmp_type;

static int hf_pim_df_elect_subtype;

static int hf_pim_df_elect_rsvd;

static int hf_pim_cksum;

static int hf_pim_cksum_status;

static int hf_pim_res_bytes;

static int hf_pim_reg_stop_p_bit;

static int hf_pim_type_13_subtype;

static int hf_pim_type_13_flagbits;

/* PIM Hello options (RFC 4601, section 4.9.2 and RFC 3973, section 4.7.5) */

static int hf_pim_option;

static int hf_pim_optiontype;

static int hf_pim_optionlength;

static int hf_pim_optionvalue;

static int hf_pim_register_flag;

static int hf_pim_register_flag_border;

static int hf_pim_register_flag_null_register;

static int hf_pim_mode;

static int hf_pim_holdtime;

static int hf_pim_holdtime_t;

static int hf_pim_numgroups;

static int hf_pim_numjoins;

static int hf_pim_numprunes;

static int hf_pim_t;

static int hf_pim_propagation_delay;

static int hf_pim_override_interval;

static int hf_pim_dr_priority;

static int hf_pim_generation_id;

static int hf_pim_state_refresh_version;

static int hf_pim_state_refresh_interval;

static int hf_pim_state_refresh_reserved;

/* Assert fields */

static int hf_pim_rpt;

static int hf_pim_metric_pref;

static int hf_pim_df_metric_pref;

static int hf_pim_metric;

static int hf_pim_prune_indicator;

static int hf_pim_prune_now;

static int hf_pim_assert_override;

static int hf_pim_ip_version;

static int hf_pim_dummy_header;

static int hf_pim_source_ip4;

static int hf_pim_source_ip6;

static int hf_pim_group_ip4;

static int hf_pim_group_ip6;

static int hf_pim_group_mask_ip4;

static int hf_pim_upstream_neighbor_ip4;

static int hf_pim_upstream_neighbor_ip6;

static int hf_pim_join_ip4;

static int hf_pim_join_ip6;

static int hf_pim_prune_ip4;

static int hf_pim_prune_ip6;

static int hf_pim_address_list_ip4;

static int hf_pim_address_list_ip6;

static int hf_pim_bsr_ip4;

static int hf_pim_bsr_ip6;

static int hf_pim_rp_ip4;

static int hf_pim_rp_ip6;

static int hf_pim_bd_bo_offer_ip4;

static int hf_pim_bd_bo_offer_ip6;

static int hf_pim_bd_offer_metric_pref;

static int hf_pim_bd_offer_metric;

static int hf_pim_bd_offer_interval;

static int hf_pim_bd_pass_ip4;

static int hf_pim_bd_pass_ip6;

static int hf_pim_bd_pass_metric_pref;

static int hf_pim_bd_pass_metric;

static int hf_pim_originator_ip4;

static int hf_pim_originator_ip6;

static int hf_pim_group_address_ip4;

static int hf_pim_fragment_tag;

static int hf_pim_hash_mask_len;

static int hf_pim_bsr_priority;

static int hf_pim_rp_count;

static int hf_pim_frp_count;

static int hf_pim_priority;

static int hf_pim_prefix_count;

static int hf_pim_addr_len;

static int hf_pim_src_flags_a;

static int hf_pim_src_flags_s;

static int hf_pim_src_flags_w;

static int hf_pim_src_flags_r;

static int hf_pim_src_flags_rsv;

static int hf_pim_mask_len;

static int hf_pim_addr_af;

static int hf_pim_addr_et;

static int hf_pim_unicast_addr_ipv4;

static int hf_pim_unicast_addr_ipv6;

static int hf_pim_rloc_addr_ipv4;

static int hf_pim_rloc_addr_ipv6;

static int hf_pim_attribute_transport_mode;

static int hf_pim_group;

static int hf_pim_group_addr_flags;

static int hf_pim_group_addr_flags_b;

static int hf_pim_group_addr_flags_reserved;

static int hf_pim_group_addr_flags_z;

static int hf_pim_source_addr_flags;

static int hf_pim_source_addr_flags_reserved;

static int hf_pim_source_addr_flags_s;

static int hf_pim_source_addr_flags_w;

static int hf_pim_source_addr_flags_r;

static int hf_pim_source_join_attribute;

static int hf_pim_source_ja_flags;

static int hf_pim_source_ja_flags_f;

static int hf_pim_source_ja_flags_e;

static int hf_pim_source_ja_flags_attr_type;

static int hf_pim_source_ja_length;

static int hf_pim_source_ja_value;

static int hf_pim_ttl;

static int hf_pim_interval;

static int hf_pim_srcount;

static int hf_pim_srcholdt;

static int hf_pim_transitivetype;

static int hf_pim_optiontype1;

static int hf_pfm_no_forward_bit;

static int ett_pim;

static int ett_pim_opts;

static int ett_pim_opt;

static int ett_pim_addr_flags;

static expert_field ei_pim_cksum;

static expert_field ei_pim_unknown_src_type;

static dissector_handle_t pim_handle;

static dissector_handle_t pimv1_handle;

static dissector_handle_t ip_handle;

static dissector_handle_t ipv6_handle;

static bool use_main_tree  = true;

/*

 * The Story About Ping^WPIM:

 *

 *   http://www.cs.usc.edu/assets/003/83187.pdf

 *

 * dated January 11, 1995, entitled "Protocol Independent Multicast (PIM):

 * Protocol Specification", calls itself draft-ietf-idmr-pim-spec-01,

 * and is in PostScript-converted-to-PDF form.  It describes a protocol

 * that runs atop IGMP, with a type of 4 for "Router PIM Messages", and

 * a PIM version number field of 1.

 *

 *   https://tools.ietf.org/html/draft-ietf-idmr-pim-sm-spec-00

 *

 * dated September 7, 1995, and

 *

 *   https://tools.ietf.org/html/draft-ietf-idmr-pim-spec-02

 *

 * dated September 7, 1995, both entitled "Protocol Independent Multicast-

 * Sparse Mode (PIM-SM): Protocol Specification", describe a protocol that

 * runs atop IGMP, with a type of 4 for "Router PIM Messages", and a PIM

 * version number field of 2.

 *

 *   https://tools.ietf.org/html/draft-ietf-idmr-pim-sm-spec-03

 *

 * dated June 6, 1996, and all subsequent drafts, and RFC 2117, dated

 * June 1997, all entitled "Protocol Independent Multicast-Sparse Mode

 * (PIM-SM): Protocol Specification", describe a protocol that runs

 * atop IP, with a protocol number of 103, and with a PIM version number

 * field of 2. RFC 2117 was obsoleted by RFC 2362, which was obsoleted by

 * RFC 4601.

 *

 * None of them, including the PDF from USC, appear to describe the protocol

 * dissected by the dissect_pimv1() code.  In particular, none have a

 * packet type value of 8 meaning "Mode"; the PDF from USC doesn't mention

 * it at all, and subsequent drafts and RFC 2117 have (Candidate-)RP-

 * Advertisement.  Perhaps what's dissected by dissect_pimv1() was

 * something between the PDF and draft-ietf-idmr-pim-spec-02.

 *

 * Looking at the Dense Mode specs,

 *

 *   https://tools.ietf.org/html/draft-ietf-idmr-pim-dm-spec-02

 *

 * entitled "Protocol Independent Multicast-Dense Mode (PIM-DM): Protocol

 * Specification", dated September 1995, describes a protocol that runs

 * atop IGMP, with a type of 4 for "Router PIM Messages", and with a PIM

 * version number field of 2.

 *

 * RFC 3973, entitled "Protocol Independent Multicast-Dense Mode (PIM-DM):

 * Protocol Specification", also describes a protocol that runs atop IP,

 * with a protocol number of 103, and with a PIM version number field of 2.

 */

static int * const pim_src_flags_fields[] = {

    &hf_pim_src_flags_a,

    &hf_pim_src_flags_s,

    &hf_pim_src_flags_w,

    &hf_pim_src_flags_r,

    &hf_pim_src_flags_rsv,

    NULL

};

static int * const pim_group_addr_flags[] = {

    &hf_pim_group_addr_flags_b,

    &hf_pim_group_addr_flags_reserved,

    &hf_pim_group_addr_flags_z,

    NULL

};

static int * const pim_source_addr_flags[] = {

    &hf_pim_source_addr_flags_reserved,

    &hf_pim_source_addr_flags_s,

    &hf_pim_source_addr_flags_w,

    &hf_pim_source_addr_flags_r,

    NULL

};

static int * const pim_source_ja_flags[] = {

    &hf_pim_source_ja_flags_f,

    &hf_pim_source_ja_flags_e,

    &hf_pim_source_ja_flags_attr_type,

    NULL

};

static void

dissect_pimv1_addr(tvbuff_t *tvb, int offset, proto_tree *pim_tree, int hf_ip) {

    proto_tree_add_bitmask_list(pim_tree, tvb, offset, 1, pim_src_flags_fields, ENC_BIG_ENDIAN);

    offset += 1;

    proto_tree_add_item(pim_tree, hf_pim_mask_len, tvb, offset, 1, ENC_BIG_ENDIAN);

    offset += 1;

    proto_tree_add_item(pim_tree, hf_ip, tvb, offset, 4, ENC_BIG_ENDIAN);

}

static const value_string pim_type1_vals[] = {

    { 0, "Query" },

    { 1, "Register" },

    { 2, "Register-stop" },

    { 3, "Join/Prune" },

    { 4, "RP-Reachable" },

    { 5, "Assert" },

    { 6, "Graft" },

    { 7, "Graft-Ack" },

    { 8, "Mode" },

    { 0, NULL },

};

static const value_string pimv1_modevals[] = {

    { 0, "Dense" },

    { 1, "Sparse" },

    { 2, "Sparse-Dense" },

    { 0, NULL }

};

static const value_string pim_ip_version_vals[] = {

    { 0, "Dummy Header" },

    { 4, "IPv4" },

    { 6, "IPv6" },

    { 0, NULL }

};

static const value_string unique_infinity[] = {

    { 0xffff, "Infinity" },

    { 0, NULL }

};

static const value_string unique_infinity_t[] = {

    { 0, "goodbye" },

    { 0xffff, "Infinity" },

    { 0, NULL }

};

/* This function is only called from the IGMP dissector */

static int

dissect_pimv1(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_) {

    uint32_t pim_type;

    uint8_t pim_ver;

    unsigned length, pim_length;

    vec_t cksum_vec[1];

    proto_tree *pim_tree = NULL;

    proto_item *ti;

    proto_tree *pimopt_tree = NULL;

    int offset = 0;

    col_set_str(pinfo->cinfo, COL_PROTOCOL, "PIMv1");

    col_clear(pinfo->cinfo, COL_INFO);

    ti = proto_tree_add_item(tree, proto_pim, tvb, offset, -1, ENC_NA);

    pim_tree = proto_item_add_subtree(ti, ett_pim);

    /* Put IGMP type, 0x14, into the tree */

    proto_tree_add_string(pim_tree, hf_pim_igmp_type, tvb, offset, 0, "PIM (0x14)");

    offset += 1;

    proto_tree_add_item_ret_uint(pim_tree, hf_pim_code, tvb, offset, 1, ENC_NA, &pim_type);

    col_add_str(pinfo->cinfo, COL_INFO, val_to_str(pinfo->pool, pim_type, pim_type1_vals, "Unknown (%u)"));

    offset += 1;

    pim_ver = PIM_VER(tvb_get_uint8(tvb, offset + 2));

    if (pim_ver != 1) {

        proto_tree_add_checksum(pim_tree, tvb, offset, hf_pim_cksum, hf_pim_cksum_status, &ei_pim_cksum, pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);

        /*

         * Not PIMv1; should we bother dissecting the PIM drafts

         * with a version number of 2 and with PIM running atop

         * IGMP?

         */

        offset += 2;

        proto_tree_add_item(pim_tree, hf_pim_version, tvb, offset, 1, ENC_BIG_ENDIAN);

        return offset+tvb_reported_length_remaining(tvb, offset);

    }

    /*

     * Well, it's PIM v1, so we can check whether this is a

     * Register message, and thus can figure out how much to

     * checksum and whether to make the columns read-only.

     */

    length = tvb_reported_length(tvb);

    if (pim_type == 1) {

        /*

         * Register message - the PIM header is 8 bytes long.

         * Also set the columns non-writable. Otherwise the IPv4 or

         * IPv6 dissector for the encapsulated packet that caused

         * this register will overwrite the PIM info in the columns.

         *

         * XXX - that's not what draft-ietf-idmr-pim-spec-01 or

         * draft-ietf-idmr-pim-spec-02 say; they say that the checksum

         * covers the entire IGMP message.  Later drafts say it

         * doesn't cover the encapsulated packet; perhaps that's what

         * was always intended, and they just felt they needed to

         * explicitly state that.

         */

        pim_length = 8;

    col_set_writable(pinfo->cinfo, -1, false);

    } else {

        /*

         * Other message - checksum the entire packet.

         */

        pim_length = length;

    }

    if (!pinfo->fragmented && length >= pim_length &&

         tvb_captured_length(tvb) >= pim_length) {

        /*

         * The packet isn't part of a fragmented datagram and isn't

         * truncated, so we can checksum it.

         */

        SET_CKSUM_VEC_TVB(cksum_vec[0], tvb, 0, pim_length);

        proto_tree_add_checksum(pim_tree, tvb, offset, hf_pim_cksum, hf_pim_cksum_status, &ei_pim_cksum,

                                pinfo, in_cksum(&cksum_vec[0], 1), ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY|PROTO_CHECKSUM_IN_CKSUM);

    } else {

        proto_tree_add_checksum(pim_tree, tvb, offset, hf_pim_cksum, hf_pim_cksum_status, &ei_pim_cksum,

                                pinfo, 0, ENC_BIG_ENDIAN, PROTO_CHECKSUM_NO_FLAGS);

    }

    offset += 2;

    proto_tree_add_item(pim_tree, hf_pim_version, tvb, offset, 1, ENC_BIG_ENDIAN);

    offset += 1;

    /* reserved stuff */

    proto_tree_add_item(pim_tree, hf_pim_res_bytes, tvb, offset, 3, ENC_NA);

    offset += 3;

    if (tvb_reported_length_remaining(tvb, offset) > 0) {

        proto_item *subitem;

        subitem = proto_tree_add_item(pim_tree, hf_pim_option, tvb, offset, -1, ENC_NA);

        pimopt_tree = proto_item_add_subtree(subitem, ett_pim_opts);

    } else

        return offset;

    /* version 1 decoder */

    switch (pim_type) {

    case 0:     /* query */

    {

        proto_tree_add_item(pimopt_tree, hf_pim_mode, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 2;

        proto_tree_add_item(pimopt_tree, hf_pim_holdtime, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

        break;

    }

    case 1:     /* register */

    {

        uint8_t v_hl;

        tvbuff_t *next_tvb;

        /*

         * The rest of the packet is a multicast data packet.

         */

        next_tvb = tvb_new_subset_remaining(tvb, offset);

        /*

         * It's an IP packet - determine whether it's IPv4 or IPv6.

         */

        v_hl = tvb_get_uint8(tvb, offset);

        proto_tree_add_item(pimopt_tree, hf_pim_ip_version, tvb, offset, 1, ENC_BIG_ENDIAN);

        switch((v_hl & 0xf0) >> 4) {

        case 0:     /* Null-Register dummy header.

                     * Has the same address family as the encapsulating PIM packet,

                     * e.g. an IPv6 data packet is encapsulated in IPv6 PIM packet.

                     */

            ti = proto_tree_add_item(pimopt_tree, hf_pim_dummy_header, tvb, offset, -1, ENC_NA);

            if (pinfo->src.type == AT_IPv4) {

                proto_item_append_text(ti, " IPv4");

                proto_tree_add_item(pimopt_tree, hf_pim_source_ip4, tvb, offset + 12, 4, ENC_BIG_ENDIAN);

                proto_tree_add_item(pimopt_tree, hf_pim_group_ip4, tvb, offset + 16, 4, ENC_BIG_ENDIAN);

            } else if (pinfo->src.type == AT_IPv6) {

                proto_item_append_text(ti, " IPv6");

                proto_tree_add_item(pimopt_tree, hf_pim_source_ip6, tvb, offset + 8, 16, ENC_NA);

                proto_tree_add_item(pimopt_tree, hf_pim_group_ip6, tvb, offset + 8 + 16, 16, ENC_NA);

            } else

                proto_item_append_text(ti, " for an unknown protocol");

            break;

        case 4: /* IPv4 */

            if (use_main_tree) {

                call_dissector(ip_handle, next_tvb, pinfo, tree);

            } else {

                call_dissector(ip_handle, next_tvb, pinfo, pimopt_tree);

            }

            break;

        case 6: /* IPv6 */

            if (use_main_tree) {

                call_dissector(ipv6_handle, next_tvb, pinfo, tree);

            } else {

                call_dissector(ipv6_handle, next_tvb, pinfo, pimopt_tree);

            }

            break;

        default:

            break;

        }

        break;

    }

    case 2:     /* register-stop */

    {

        proto_tree_add_item(pimopt_tree, hf_pim_group_ip4, tvb, offset, 4, ENC_BIG_ENDIAN);

        offset += 4;

        proto_tree_add_item(pimopt_tree, hf_pim_source_ip4, tvb, offset, 4, ENC_BIG_ENDIAN);

        offset += 4;

        break;

    }

    case 3:     /* join/prune */

    case 6:     /* graft */

    case 7:     /* graft-ack */

    {

        int off;

        int ngroup, i, njoin, nprune, j;

        proto_tree *grouptree = NULL;

        proto_item *tigroup;

        proto_tree *subtree = NULL;

        proto_item *tisub;

        proto_tree_add_item(pimopt_tree, hf_pim_upstream_neighbor_ip4, tvb, offset, 4, ENC_BIG_ENDIAN);

        offset += 4;

        /* reserved stuff */

        proto_tree_add_item(pim_tree, hf_pim_res_bytes, tvb, offset, 2, ENC_NA);

        offset += 2;

        proto_tree_add_item(pimopt_tree, hf_pim_holdtime, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

        /* reserved stuff */

        proto_tree_add_item(pim_tree, hf_pim_res_bytes, tvb, offset, 1, ENC_NA);

        offset += 1;

        proto_tree_add_item(pimopt_tree, hf_pim_mask_len, tvb, offset, 1, ENC_NA);

        offset += 1;

        proto_tree_add_item(pimopt_tree, hf_pim_addr_len, tvb, offset, 1, ENC_NA);

        offset += 1;

        ngroup = tvb_get_uint8(tvb, offset);

        proto_tree_add_item(pimopt_tree, hf_pim_numgroups, tvb, offset, 1, ENC_BIG_ENDIAN);

        offset += 1;

        for (i = 0; i < ngroup; i++) {

            /*

             * XXX - does the group address have the length "adr_len"

             * and the group mask the length "mask_len"?

             */

            tigroup = proto_tree_add_ipv4_format(pimopt_tree, hf_pim_group_ip4, tvb, offset, 4,

                                tvb_get_ipv4(tvb, offset), "Group %d: %s", i, tvb_ip_to_str(pinfo->pool, tvb, offset));

            grouptree = proto_item_add_subtree(tigroup, ett_pim);

            offset += 4;

            proto_tree_add_ipv4_format(grouptree, hf_pim_group_mask_ip4, tvb, offset, 4,

                                tvb_get_ipv4(tvb, offset), "Group %d Mask: %s", i, tvb_ip_to_str(pinfo->pool, tvb, offset));

            offset += 4;

            njoin = tvb_get_ntohs(tvb, offset);

            nprune = tvb_get_ntohs(tvb, offset + 2);

            tisub = proto_tree_add_item(grouptree, hf_pim_numjoins, tvb,

                                        offset, 2, ENC_BIG_ENDIAN);

            subtree = proto_item_add_subtree(tisub, ett_pim);

            off = offset + 4;

            for (j = 0; j < njoin; j++) {

                dissect_pimv1_addr(tvb, off, subtree, hf_pim_join_ip4);

                off += 6;

            }

            tisub = proto_tree_add_item(grouptree, hf_pim_numprunes, tvb,

                                        offset + 2, 2, ENC_BIG_ENDIAN);

            subtree = proto_item_add_subtree(tisub, ett_pim);

            for (j = 0; j < nprune; j++) {

                dissect_pimv1_addr(tvb, off, subtree, hf_pim_prune_ip4);

                off += 6;

            }

            offset = off;

        }

        break;

    }

    case 4:     /* rp-reachability */

    {

        proto_tree_add_item(pimopt_tree, hf_pim_group_address_ip4, tvb, offset, 4, ENC_BIG_ENDIAN);

        offset += 4;

        proto_tree_add_item(pimopt_tree, hf_pim_group_mask_ip4, tvb, offset, 4, ENC_BIG_ENDIAN);

        offset += 4;

        proto_tree_add_item(pimopt_tree, hf_pim_rp_ip4, tvb, offset, 4, ENC_BIG_ENDIAN);

        offset += 4;

        /* reserved stuff */

        proto_tree_add_item(pim_tree, hf_pim_res_bytes, tvb, offset, 2, ENC_NA);

        offset += 2;

        proto_tree_add_item(pimopt_tree, hf_pim_holdtime, tvb, offset, 2, ENC_BIG_ENDIAN);

        offset += 2;

        break;

    }

    case 5:     /* assert */

    {

        proto_tree_add_item(pimopt_tree, hf_pim_group_address_ip4, tvb, offset, 4, ENC_BIG_ENDIAN);

        offset += 4;

        proto_tree_add_item(pimopt_tree, hf_pim_group_mask_ip4, tvb, offset, 4, ENC_BIG_ENDIAN);

        offset += 4;

        proto_tree_add_item(pimopt_tree, hf_pim_rpt, tvb, offset, 1, ENC_BIG_ENDIAN);

        proto_tree_add_item(pimopt_tree, hf_pim_metric_pref, tvb,

                                   offset, 4, ENC_BIG_ENDIAN);

        offset += 4;

        proto_tree_add_item(pimopt_tree, hf_pim_metric, tvb, offset, 4, ENC_BIG_ENDIAN);

        offset += 4;

        break;

    }

    default:

        break;

    }

    return offset;

}

static bool

// NOLINTNEXTLINE(misc-no-recursion)

dissect_pim_addr(packet_info *pinfo, proto_tree* tree, tvbuff_t *tvb, int offset, enum pimv2_addrtype at,

                 const char* label, proto_item** ret_item, int hf_ip4, int hf_ip6, int *advance) {

    uint8_t af, et, flags, mask_len, ja_af;

    ws_in6_addr ipv6;

    uint32_t ipv4 = 0;

    proto_item* ti = NULL;

    proto_tree* addr_tree = NULL;

    proto_item *rloc_tree = NULL;

    proto_tree *rloc_sub_tree = NULL;

    proto_tree* ja_tree = NULL;

    int len = 0;

    int ja_offset = 0;

    uint8_t ja_eos_type = 0;

    uint8_t ja_length = 0;

    int ja_length_sum = 0;

    af = tvb_get_uint8(tvb, offset);

    if (af != AFNUM_IP && af != AFNUM_IP6) {

        /*

         * We don't handle the other formats, and addresses don't include

         * a length field, so we can't even show them as raw bytes.

         */

        return false;

    }

    et = tvb_get_uint8(tvb, offset + 1);

    if ((et != PIM_ADDR_ET_NATIVE) && (et != PIM_ADDR_ET_NATIVE_JA)) {

        /*

         * The only defined encoding type is 0 and 1, for the native encoding

         * and native with Join Attribute TLVs;

         * again, as addresses don't include a length field, we can't

         * even show addresses with a different encoding type as raw

         * bytes.

         */

        return false;

    }

    switch (at) {

    case pimv2_unicast:

        switch (af) {

        case AFNUM_IP:

            len = 4;

            ipv4 = tvb_get_ipv4(tvb, offset + 2);

            if (label)

            {

                ti = proto_tree_add_ipv4_format(tree, hf_ip4, tvb, offset, 2 + len,

                                ipv4, "%s: %s", label, tvb_ip_to_str(pinfo->pool, tvb, offset + 2));

            }

            else

            {

                ti = proto_tree_add_ipv4(tree, hf_ip4, tvb, offset, 2 + len, ipv4);

            }

            break;

        case AFNUM_IP6:

            len = 16;

            tvb_get_ipv6(tvb, offset + 2, &ipv6);

            if (label)

            {

                ti = proto_tree_add_ipv6_format(tree, hf_ip6, tvb, offset, 2 + len,

                        &ipv6, "%s: %s", label, tvb_ip6_to_str(pinfo->pool, tvb, offset + 2));

            }

            else

            {

                ti = proto_tree_add_ipv6(tree, hf_ip6, tvb, offset, 2 + len, &ipv6);

            }

            break;

        }

        addr_tree = proto_item_add_subtree(ti, ett_pim);

        proto_tree_add_item(addr_tree, hf_pim_addr_af, tvb, offset, 1, ENC_NA);

        proto_tree_add_item(addr_tree, hf_pim_addr_et, tvb, offset+1, 1, ENC_NA);

        switch (af) {

        case AFNUM_IP:

            proto_tree_add_item(addr_tree, hf_pim_unicast_addr_ipv4, tvb, offset+2, 4, ENC_BIG_ENDIAN);

            break;

        case AFNUM_IP6:

            proto_tree_add_item(addr_tree, hf_pim_unicast_addr_ipv6, tvb, offset+2, 16, ENC_NA);

            break;

        }

        if (et == PIM_ADDR_ET_NATIVE_JA){

            ja_offset = offset + len + 2;

            while (((ja_eos_type & 0x40) != 0x40) && (tvb_reported_length_remaining(tvb, ja_offset) >= 2)){

                ja_length = tvb_get_uint8(tvb, ja_offset+1);

                ti = proto_tree_add_item(addr_tree, hf_pim_source_join_attribute, tvb, ja_offset, ja_length + 2, ENC_NA);

                ja_tree = proto_item_add_subtree(ti, ett_pim);

                ja_eos_type = tvb_get_uint8(tvb, ja_offset);

                proto_tree_add_bitmask(ja_tree, tvb, ja_offset, hf_pim_source_ja_flags,

                                       ett_pim_addr_flags, pim_source_ja_flags, ENC_BIG_ENDIAN);

                proto_item_append_text(ti, ": %s", val_to_str_const(ja_eos_type & 0x3F, pim_join_attribute_type_vals, "Unknown"));

                ja_offset += 1;

                proto_tree_add_item(ja_tree, hf_pim_source_ja_length, tvb, ja_offset, 1, ENC_BIG_ENDIAN);

                ja_offset += 1;

                switch(ja_eos_type & 0x3F){

                    case PIM_JOIN_ATTRIBUTE_TYPE_TA:

                        proto_tree_add_item(ja_tree, hf_pim_attribute_transport_mode, tvb, ja_offset, 1, ENC_NA);

                        break;

                    case PIM_JOIN_ATTRIBUTE_TYPE_RLOC:

                        ja_af = tvb_get_uint8(tvb, offset);

                        switch(ja_af) {

                            case AFNUM_IP:

                                rloc_tree = proto_tree_add_ipv4_format(ja_tree, hf_ip4, tvb, ja_offset, ja_length,

                                                                       ipv4, "RLOC: %s", tvb_ip_to_str(pinfo->pool, tvb, ja_offset+ 1));

                                rloc_sub_tree = proto_item_add_subtree(rloc_tree, ett_pim);

                                proto_tree_add_item(rloc_sub_tree, hf_pim_addr_af, tvb, ja_offset, 1, ENC_NA);

                                proto_tree_add_item(rloc_sub_tree, hf_pim_rloc_addr_ipv4, tvb, ja_offset + 1, 4, ENC_BIG_ENDIAN);

                                break;

                            case AFNUM_IP6:

                                rloc_tree = proto_tree_add_ipv6_format(ja_tree, hf_ip6, tvb, ja_offset, ja_length,

                                                                       &ipv6, "RLOC: %s", tvb_ip_to_str(pinfo->pool, tvb, ja_offset+ 1));

                                rloc_sub_tree = proto_item_add_subtree(rloc_tree, ett_pim);

                                proto_tree_add_item(rloc_sub_tree, hf_pim_addr_af, tvb, ja_offset, 1, ENC_NA);

                                proto_tree_add_item(rloc_sub_tree, hf_pim_rloc_addr_ipv6, tvb, ja_offset + 1, 16, ENC_NA);

                                break;

                        }

                        break;

                    default:

                        break;

                }

                ja_offset += ja_length;

                ja_length_sum += (2 + (int)ja_length);

            }

            *advance = 2 + len + ja_length_sum;

            break;

        }

        *advance = 2 + len;

        break;

    case pimv2_group:

        mask_len = tvb_get_uint8(tvb, offset + 3);

        switch (af) {

        case AFNUM_IP:

            len = 4;

            ipv4 = tvb_get_ipv4(tvb, offset + 4);

            if (label)

            {

                ti = proto_tree_add_ipv4_format(tree, hf_ip4, tvb, offset, 4 + len,

                                ipv4, "%s: %s", label, tvb_ip_to_str(pinfo->pool, tvb, offset + 4));

            }

            else

            {

                ti = proto_tree_add_ipv4(tree, hf_ip4, tvb, offset, 4 + len, ipv4);

            }

            proto_item_append_text(ti, "/%u", mask_len);

            break;

        case AFNUM_IP6:

            len = 16;

            tvb_get_ipv6(tvb, offset + 4, &ipv6);

            if (label)

            {

                ti = proto_tree_add_ipv6_format(tree, hf_ip6, tvb, offset, 4 + len,

                        &ipv6, "%s: %s", label, tvb_ip6_to_str(pinfo->pool, tvb, offset + 4));

            }

            else

            {

                ti = proto_tree_add_ipv6(tree, hf_ip6, tvb, offset, 4 + len, &ipv6);

            }

            proto_item_append_text(ti, "/%u", mask_len);

            break;

        }

        addr_tree = proto_item_add_subtree(ti, ett_pim);

        proto_tree_add_item(addr_tree, hf_pim_addr_af, tvb, offset, 1, ENC_NA);

        proto_tree_add_item(addr_tree, hf_pim_addr_et, tvb, offset+1, 1, ENC_NA);

        proto_tree_add_bitmask(addr_tree, tvb, offset+2, hf_pim_group_addr_flags,

                ett_pim_addr_flags, pim_group_addr_flags, ENC_BIG_ENDIAN);

        proto_tree_add_item(addr_tree, hf_pim_mask_len, tvb, offset+3, 1, ENC_NA);

        switch (af) {

        case AFNUM_IP:

            proto_tree_add_item(addr_tree, hf_pim_group_ip4, tvb, offset+4, 4, ENC_BIG_ENDIAN);

            break;

        case AFNUM_IP6:

            proto_tree_add_item(addr_tree, hf_pim_group_ip6, tvb, offset+4, 16, ENC_NA);

            break;

        }

        *advance = 4 + len;

        break;

    case pimv2_source:

        flags = tvb_get_uint8(tvb, offset + 2);

        mask_len = tvb_get_uint8(tvb, offset + 3);

        switch (af) {

        case AFNUM_IP:

            len = 4;

            ipv4 = tvb_get_ipv4(tvb, offset + 4);

            if (label)

            {

                ti = proto_tree_add_ipv4_format(tree, hf_ip4, tvb, offset, 4 + len,

                                ipv4, "%s: %s", label, tvb_ip_to_str(pinfo->pool, tvb, offset + 4));

            }

            else

            {

                ti = proto_tree_add_ipv4_format_value(tree, hf_ip4, tvb, offset, 4 + len, ipv4,

                                                      "%s", tvb_ip_to_str(pinfo->pool, tvb, offset + 4));

            }

            proto_item_append_text(ti, "/%u", mask_len);

            break;

        case AFNUM_IP6:

            len = 16;

            tvb_get_ipv6(tvb, offset + 4, &ipv6);

            if (label)

            {

                ti = proto_tree_add_ipv6_format(tree, hf_ip6, tvb, offset, 4 + len,

                        &ipv6, "%s: %s", label, tvb_ip6_to_str(pinfo->pool, tvb, offset + 4));

            }

            else

            {

                ti = proto_tree_add_ipv6_format_value(tree, hf_ip6, tvb, offset, 4 + len, &ipv6,

                                                      "%s", tvb_ip6_to_str(pinfo->pool, tvb, offset + 4));

            }

            proto_item_append_text(ti, "/%u", mask_len);

            break;

        }

        if (flags) {

            proto_item_append_text(ti, " (%s%s%s)",

                                    flags & 0x04 ? "S" : "",

                                    flags & 0x02 ? "W" : "",

                                    flags & 0x01 ? "R" : "");

        }

        addr_tree = proto_item_add_subtree(ti, ett_pim);

        proto_tree_add_item(addr_tree, hf_pim_addr_af, tvb, offset, 1, ENC_NA);

        proto_tree_add_item(addr_tree, hf_pim_addr_et, tvb, offset+1, 1, ENC_NA);

        proto_tree_add_bitmask(addr_tree, tvb, offset+2, hf_pim_source_addr_flags,

                ett_pim_addr_flags, pim_source_addr_flags, ENC_BIG_ENDIAN);

        proto_tree_add_item(addr_tree, hf_pim_mask_len, tvb, offset+3, 1, ENC_NA);

        switch (af) {

        case AFNUM_IP:

            proto_tree_add_item(addr_tree, hf_pim_source_ip4, tvb, offset+4, 4, ENC_BIG_ENDIAN);

            break;

        case AFNUM_IP6:

            proto_tree_add_item(addr_tree, hf_pim_source_ip6, tvb, offset+4, 16, ENC_NA);

            break;

        }

        if (et == PIM_ADDR_ET_NATIVE_JA) {

            ja_offset = offset + 4 + len;

            while (((ja_eos_type & 0x40) != 0x40) && (tvb_reported_length_remaining(tvb, ja_offset) >= 2)) {

                ja_length = tvb_get_uint8(tvb, ja_offset+1);

                ti = proto_tree_add_item(addr_tree, hf_pim_source_join_attribute, tvb, ja_offset, ja_length + 2, ENC_NA);

                ja_tree = proto_item_add_subtree(ti, ett_pim);

                ja_eos_type = tvb_get_uint8(tvb, ja_offset);

                proto_tree_add_bitmask(ja_tree, tvb, ja_offset, hf_pim_source_ja_flags,

                            ett_pim_addr_flags, pim_source_ja_flags, ENC_BIG_ENDIAN);

                proto_item_append_text(ti, ": %s", val_to_str_const(ja_eos_type & 0x3F, pim_join_attribute_type_vals, "Unknown"));

                ja_offset += 1;

                proto_tree_add_item(ja_tree, hf_pim_source_ja_length, tvb, ja_offset, 1, ENC_BIG_ENDIAN);

                ja_offset += 1;

                switch(ja_eos_type & 0x3F) {

                    case PIM_JOIN_ATTRIBUTE_TYPE_RPF:

                        if ((ja_length == 6) || (ja_length == 18)) {

                            int advance_attr;

                            // We recurse here, but we'll run out of packet before we run out of stack.

                            if (!dissect_pim_addr(pinfo, ja_tree, tvb, ja_offset, pimv2_unicast, NULL, NULL,

                                    hf_pim_unicast_addr_ipv4, hf_pim_unicast_addr_ipv6, &advance_attr))

                                break;

                        } else {

                            proto_tree_add_item(ja_tree, hf_pim_source_ja_value, tvb, ja_offset, ja_length, ENC_NA);

                        }

                        break;

                    case PIM_JOIN_ATTRIBUTE_TYPE_RLOC:

                        ja_af = tvb_get_uint8(tvb, offset);

                        switch(ja_af) {

                            case AFNUM_IP:

                                rloc_tree = proto_tree_add_ipv4_format(ja_tree, hf_ip4, tvb, ja_offset, ja_length,

                                                                       ipv4, "RLOC: %s", tvb_ip_to_str(pinfo->pool, tvb, ja_offset+ 1));

                                rloc_sub_tree = proto_item_add_subtree(rloc_tree, ett_pim);

                                proto_tree_add_item(rloc_sub_tree, hf_pim_addr_af, tvb, ja_offset, 1, ENC_NA);