/* packet-wifi-nan.c

 *

 * Wi-Fi Neighbour Awareness Networking (NAN)

 *

 * Copyright 2019 Samsung Electronics

 *

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

 */

#include <config.h>

#include <epan/packet.h>

#include <epan/expert.h>

#include <epan/tfs.h>

#include <wsutil/array.h>

#include "packet-ieee80211.h"

#include <wsutil/str_util.h>

void proto_reg_handoff_nan(void);

void proto_register_nan(void);

static dissector_handle_t nan_act_handle;

static dissector_handle_t nan_disco_handle;

static dissector_handle_t nan_beacon_handle;

static dissector_table_t ie_handle_table;

#define WFA_ACTION_OUI_TYPE 0x18

#define WFA_NAN_IE_OUI_TYPE 0x13

#define WFA_SERVICE_DISCOVERY_SUBTYPE 0x13

#define NAN_MASTER_IND_LENGTH 2

#define NAN_CLUSTER_LENGTH 13

#define NAN_SDA_MIN_LENGTH 9

#define NAN_SDEA_MIN_LENGTH 3

#define NAN_CONNECTION_CAP_LENGTH 2

#define NAN_WLAN_INFRA_MIN_LENGTH 15

#define NAN_P2P_OP_MIN_LENGTH 9

#define NAN_IBSS_MIN_LENGTH 14

#define NAN_MESH_MIN_LENGTH 8

#define NAN_RANGING_MIN_LENGTH 8

#define NAN_CLUSTER_DISC_LENGTH 22

#define NAN_DEVICE_CAP_LENGTH 9

#define NAN_NDP_MIN_LENGTH 11

#define NAN_NDPE_MIN_LENGTH 11

#define NAN_AVAILABILITY_MIN_LENGTH 8

#define NAN_NDC_MIN_LENGTH 11

#define NAN_NDL_MIN_LENGTH 4

#define NAN_NDL_QOS_LENGTH 3

#define NAN_UNALIGNED_SCH_MIN_LENGTH 16

#define NAN_RANGING_SETUP_MIN_LENGTH 4

#define NAN_EXTENDED_WLAN_INFRA_LENGTH 20

#define NAN_EXTENDED_P2P_OP_LENGTH 14

#define NAN_EXTENDED_IBSS_LENGTH 19

#define NAN_EXTENDED_MESH_MIN_LENGTH 13

#define NAN_CIPHER_SUITE_INFO_MIN_LENGTH 3

#define NAN_SECURITY_CONTEXT_INFO_MIN_LENGTH 4

#define NAN_PUBLIC_AVAIL_MIN_LENGTH 4

#define NAN_VENDOR_SPECIFIC_MIN_LENGTH 3

#define NAN_DEVICE_CAPABILITY_EXTENSION_MIN_LENGTH 2

#define NAN_IDENTITY_RESOLUTION_MIN_LEN 1

#define NAN_PAIRING_BOOTSTRAPPING_LEN 5

#define NAN_UNALIGNED_SCH_BAND_ID_EXIST 0

#define NAN_UNALIGNED_SCH_CHANNEL_ENTRY_EXIST 1

#define NAN_UNALIGNED_SCH_CHANNEL_ENTRY_W_AUX_EXIST 2

static int proto_nan;

static expert_field ei_nan_elem_len_invalid;

static expert_field ei_nan_unknown_attr_id;

static expert_field ei_nan_unknown_op_class;

static expert_field ei_nan_unknown_beacon_type;

static expert_field ei_nan_invalid_channel_num_for_op_class;

static expert_field ei_nan_invalid_channel_count;

static int ett_nan;

static int ett_attributes;

static int ett_map_control;

static int ett_type_status;

static int ett_time_bitmap_ctrl;

static int ett_non_nan_op_channel;

static int ett_non_nan_beacon;

static int ett_cluster_anchor_master_info;

static int ett_sda_service_ctr;

static int ett_sda_srf_ctr;

static int ett_sdea_ctr;

static int ett_sdea_range_limit;

static int ett_sdea_service_info;

static int ett_connection_cap_field;

static int ett_further_av_map_entry_ctrl;

static int ett_device_cap_map_id;

static int ett_device_cap_committed_dw;

static int ett_device_cap_supported_bands;

static int ett_device_cap_op_mode;

static int ett_device_cap_antennas;

static int ett_device_cap_capabilities;

static int ett_ndp_control;

static int ett_ndpe_tlv;

static int ett_availability_ctr;

static int ett_availability_entry;

static int ett_availability_entry_ctr;

static int ett_availability_entry_entries;

static int ett_availability_entry_entries_channel;

static int ett_ndc_ctr;

static int ett_ndc_entries;

static int ett_device_ndc_map_id;

static int ett_ndl_control;

static int ett_ndl_schedule_entries;

static int ett_unaligned_sch_ctrl;

static int ett_unaligned_sch_ulw_overwrite;

static int ett_unaligned_sch_ulw_ctrl;

static int ett_ranging_setup_ftm_params;

static int ett_ranging_setup_ctrl;

static int ett_ranging_setup_schedule_entries;

static int ett_ranging_info_location_info_availability;

static int ett_p2p_device_role;

static int ett_cipher_suite_info_list;

static int ett_security_context_identifiers;

static int ett_public_availability_sch_entries;

static int ett_ie_tree;

static int ett_availability_op_class;

static int ett_device_capability_extension;

static int ett_nan_pairing_bootstrapping_type_status;

static int ett_nan_pairing_bootstrapping_method;

static int ett_nan_cipher_suite_capabilities;

static int hf_nan_attribute_type;

static int hf_nan_attribute_len;

static int hf_nan_action_subtype;

static int hf_nan_instance_id;

static int hf_nan_service_id;

static int hf_nan_map_id;

static int hf_nan_oui;

static int hf_nan_type_status;

static int hf_nan_reason_code;

static int hf_nan_status_1;

static int hf_nan_status_2;

static int hf_nan_bss_id;

static int hf_nan_availability_intervals_bitmap;

static int hf_nan_mac_address;

static int hf_nan_publish_id;

static int hf_nan_dialog_tokens;

static int hf_nan_time_bitmap;

static int hf_nan_time_bitmap_len;

static int hf_nan_time_bitmap_ctrl;

static int hf_nan_time_bitmap_ctrl_bit_duration;

static int hf_nan_time_bitmap_ctrl_period;

static int hf_nan_time_bitmap_ctrl_start_offset;

static int hf_nan_map_ctrl_map_id;

static int hf_nan_map_ctrl_availability_interval_duration;

static int hf_nan_map_ctrl_repeat;

static int hf_nan_map_ctrl_field;

static int hf_nan_non_op_channel_global_op_class;

static int hf_nan_non_op_channel_channel;

static int hf_nan_non_op_channel_center_freq;

static int hf_nan_non_beacon_tbtt_offset;

static int hf_nan_non_beacon_interval;

static int hf_nan_attr_master_preference;

static int hf_nan_attr_master_random_factor;

static int hf_nan_attr_cluster_anchor_master_rank;

static int hf_nan_attr_cluster_hop_count;

static int hf_nan_attr_cluster_beacon_transmission_time;

static int hf_nan_attr_sda_requestor_instance_id;

static int hf_nan_attr_sda_sc;

static int hf_nan_attr_sda_sc_type;

static int hf_nan_attr_sda_sc_matching_filter;

static int hf_nan_attr_sda_sc_service_response;

static int hf_nan_attr_sda_sc_service_info;

static int hf_nan_attr_sda_sc_discovery_range;

static int hf_nan_attr_sda_sc_binding_bitmap;

static int hf_nan_attr_sda_binding_bitmap;

static int hf_nan_attr_sda_matching_filter_len;

static int hf_nan_attr_sda_matching_filter_val;

static int hf_nan_attr_sda_service_response_filter_len;

static int hf_nan_attr_sda_srf_ctr;

static int hf_nan_attr_sda_srf_ctr_type;

static int hf_nan_attr_sda_srf_ctr_include;

static int hf_nan_attr_sda_srf_ctr_bloom_filter_index;

static int hf_nan_attr_sda_srf_address_set;

static int hf_nan_attr_sda_service_info_len;

static int hf_nan_attr_sda_service_info;

static int hf_nan_attr_sdea_ctr;

static int hf_nan_attr_sdea_ctr_fsd;

static int hf_nan_attr_sdea_ctr_fsd_w_gas;

static int hf_nan_attr_sdea_ctr_data_path;

static int hf_nan_attr_sdea_ctr_data_path_type;

static int hf_nan_attr_sdea_ctr_reserved_multicast_type;

static int hf_nan_attr_sdea_ctr_qos;

static int hf_nan_attr_sdea_ctr_security;

static int hf_nan_attr_sdea_ctr_ranging;

static int hf_nan_attr_sdea_ctr_range_limit;

static int hf_nan_attr_sdea_ctr_service_update_indicator;

static int hf_nan_attr_sdea_ingress_range_limit;

static int hf_nan_attr_sdea_egress_range_limit;

static int hf_nan_attr_sdea_service_update_indicator;

static int hf_nan_attr_sdea_service_info_length;

static int hf_nan_attr_sdea_service_info_protocol_type;

static int hf_nan_attr_sdea_service_info_specific;

static int hf_nan_attr_connection_cap_bitmap;

static int hf_nan_attr_connection_cap_wifi_direct;

static int hf_nan_attr_connection_cap_p2ps;

static int hf_nan_attr_connection_cap_tdls;

static int hf_nan_attr_connection_cap_wlan_infra;

static int hf_nan_attr_connection_cap_ibss;

static int hf_nan_attr_connection_cap_mesh;

static int hf_nan_attr_wlan_infra_device_role;

static int hf_nan_attr_p2p_device_role_device;

static int hf_nan_attr_p2p_device_role_group_owner;

static int hf_nan_attr_p2p_device_role_client;

static int hf_nan_attr_p2p_device_role;

static int hf_nan_attr_mesh_id;

static int hf_nan_attr_further_av_map_entry_av_interval_duration;

static int hf_nan_attr_further_av_map_op_class;

static int hf_nan_attr_further_av_map_channel_num;

static int hf_nan_attr_further_av_map_entry_ctrl;

static int hf_nan_attr_further_av_map_id;

static int hf_nan_attr_country_code;

static int hf_nan_attr_ranging_protocol;

static int hf_nan_attr_cluster_disc_id;

static int hf_nan_attr_cluster_disc_time_offset;

static int hf_nan_attr_cluster_disc_anchor_master_rank;

static int hf_nan_attr_device_cap_map_id_apply_to;

static int hf_nan_attr_device_cap_map_id_associated_maps;

static int hf_nan_attr_device_cap_committed_dw;

static int hf_nan_attr_device_cap_committed_dw_24ghz;

static int hf_nan_attr_device_cap_committed_dw_5ghz;

static int hf_nan_attr_device_cap_committed_dw_24ghz_overwrite;

static int hf_nan_attr_device_cap_committed_dw_5ghz_overwrite;

static int hf_nan_attr_device_cap_supported_bands;

static int hf_nan_attr_device_cap_supported_bands_reserved_tv_whitespaces;

static int hf_nan_attr_device_cap_supported_bands_sub_1ghz;

static int hf_nan_attr_device_cap_supported_bands_24ghz;

static int hf_nan_attr_device_cap_supported_bands_reserved_36ghz;

static int hf_nan_attr_device_cap_supported_bands_5ghz;

static int hf_nan_attr_device_cap_supported_bands_reserved_60ghz;

static int hf_nan_attr_device_cap_supported_bands_reserved_45ghz;

static int hf_nan_attr_device_cap_supported_bands_6ghz;

static int hf_nan_attr_device_cap_op_mode;

static int hf_nan_attr_device_cap_op_mode_phy_vht;

static int hf_nan_attr_device_cap_op_mode_phy_he;

static int hf_nan_attr_device_cap_op_mode_phy_he_vht8080;

static int hf_nan_attr_device_cap_op_mode_phy_he_vht160;

static int hf_nan_attr_device_cap_op_mode_reserved_paging_ndl;

static int hf_nan_attr_device_cap_antennas;

static int hf_nan_attr_device_cap_antennas_tx;

static int hf_nan_attr_device_cap_antennas_rx;

static int hf_nan_attr_device_cap_max_channel_switch_time;

static int hf_nan_attr_device_cap_capabilities;

static int hf_nan_attr_device_cap_capabilities_dfs_master;

static int hf_nan_attr_device_cap_capabilities_extended_key_id;

static int hf_nan_attr_device_cap_capabilities_simul_ndp_reception;

static int hf_nan_attr_device_cap_capabilities_ndpe_attr_support;

static int hf_nan_attr_device_cap_capabilities_s3_capable;

static int hf_nan_attr_ndp_type;

static int hf_nan_attr_ndp_initiator;

static int hf_nan_attr_ndp_id;

static int hf_nan_attr_ndp_ctrl_confirm;

static int hf_nan_attr_ndp_ctrl_security_pres;

static int hf_nan_attr_ndp_ctrl_publish_id_pres;

static int hf_nan_attr_ndp_ctrl_responder_ndi_pres;

static int hf_nan_attr_ndp_ctrl_sepcific_info_pres;

static int hf_nan_attr_ndpe_ctrl_confirm;

static int hf_nan_attr_ndpe_ctrl_security_pres;

static int hf_nan_attr_ndpe_ctrl_publish_id_pres;

static int hf_nan_attr_ndpe_ctrl_responder_ndi_pres;

static int hf_nan_attr_ndpe_ctrl_gtk_requried;

static int hf_nan_attr_ndp_control;

static int hf_nan_attr_ndpe_control;

static int hf_nan_attr_ndp_responder_ndi;

static int hf_nan_attr_ndp_specific_info;

static int hf_nan_attr_ndpe_tlv_type;

static int hf_nan_attr_ndpe_tlv_len;

static int hf_nan_attr_ndpe_tlv_ipv6_interface_identifier;

static int hf_nan_attr_availability_sequence_id;

static int hf_nan_attr_availability_ctr;

static int hf_nan_attr_availability_map_id;

static int hf_nan_attr_availability_committed_changed;

static int hf_nan_attr_availability_potential_changed;

static int hf_nan_attr_availability_public_availability_changed;

static int hf_nan_attr_availability_ndc_changed;

static int hf_nan_attr_availability_reserved_multicast_schedule_changed;

static int hf_nan_attr_availability_reserved_multicast_schedule_change_changed;

static int hf_nan_attr_availability_entry_len;

static int hf_nan_attr_availability_entry_ctr;

static int hf_nan_attr_availability_entry_ctr_type;

static int hf_nan_attr_availability_entry_ctr_pref;

static int hf_nan_attr_availability_entry_ctr_utilization;

static int hf_nan_attr_availability_entry_ctr_rx_nss;

static int hf_nan_attr_availability_entry_ctr_time_bitmap;

static int hf_nan_attr_availability_entry_entries_type;

static int hf_nan_attr_availability_entry_entries_non_contiguous_bw;

static int hf_nan_attr_availability_entry_entries_num_entries;

static int hf_nan_attr_availability_entry_entries_band;

static int hf_nan_attr_availability_entry_entries_channel_op_class;

static int hf_nan_attr_availability_entry_entries_channel_bitmap;

static int hf_nan_attr_availability_entry_entries_primary_channel_bitmap;

static int hf_nan_attr_availability_entry_entries_aux_channel_bitmap;

static int hf_nan_attr_availability_entry_entries_channel_set;

static int hf_nan_attr_availability_entry_entries_start_channel_number;

static int hf_nan_attr_availability_entry_entries_number_of_ch_included;

static int hf_nan_attr_availability_entry_entries_start_freq;

static int hf_nan_attr_availability_entry_entries_bandwidth;

static int hf_nan_attr_ndc_id;

static int hf_nan_attr_ndc_ctrl;

static int hf_nan_attr_ndc_ctrl_selected;

static int hf_nan_attr_ndc_map_id_related_sch;

static int hf_nan_attr_ndl_type;

static int hf_nan_attr_ndl_control;

static int hf_nan_attr_ndl_ctrl_peer_id;

static int hf_nan_attr_ndl_ctrl_immutable_schedule_pres;

static int hf_nan_attr_ndl_ctrl_ndc_pres;

static int hf_nan_attr_ndl_ctrl_qos;

static int hf_nan_attr_ndl_ctrl_type;

static int hf_nan_attr_ndl_ctrl_setup_reason;

static int hf_nan_attr_ndl_ctrl_max_idle_pres;

static int hf_nan_attr_ndl_reserved_peer_id;

static int hf_nan_attr_ndl_max_idle;

static int hf_nan_attr_ndlqos_min_time_slots;

static int hf_nan_attr_ndlqos_max_latency;

static int hf_nan_attr_unaligned_sch_ctrl;

static int hf_nan_attr_unaligned_sch_ctrl_schedule_id;

static int hf_nan_attr_unaligned_sch_ctrl_seq_id;

static int hf_nan_attr_unaligned_sch_starting_time;

static int hf_nan_attr_unaligned_sch_duration;

static int hf_nan_attr_unaligned_sch_period;

static int hf_nan_attr_unaligned_sch_count_down;

static int hf_nan_attr_unaligned_sch_ulw_overwrite;

static int hf_nan_attr_unaligned_sch_ulw_overwrite_all;

static int hf_nan_attr_unaligned_sch_ulw_overwrite_map_id;

static int hf_nan_attr_unaligned_sch_ulw_ctrl;

static int hf_nan_attr_unaligned_sch_ulw_ctrl_type;

static int hf_nan_attr_unaligned_sch_ulw_ctrl_channel_av;

static int hf_nan_attr_unaligned_sch_ulw_ctrl_rxnss;

static int hf_nan_attr_ranging_info_location_info_avail;

static int hf_nan_attr_ranging_info_location_info_avail_lci;

static int hf_nan_attr_ranging_info_location_info_avail_geospatial;

static int hf_nan_attr_ranging_info_location_info_avail_civic_location;

static int hf_nan_attr_ranging_info_location_info_avail_last_movement_pres;

static int hf_nan_attr_ranging_info_last_movement_indication;

static int hf_nan_attr_ranging_setup_type;

static int hf_nan_attr_ranging_setup_ctrl;

static int hf_nan_attr_ranging_setup_ctrl_report_req;

static int hf_nan_attr_ranging_setup_ctrl_ftm_params;

static int hf_nan_attr_ranging_setup_ctrl_entry_list;

static int hf_nan_attr_ranging_setup_ftm_params;

static int hf_nan_attr_ranging_setup_ftm_max_per_burst;

static int hf_nan_attr_ranging_setup_ftm_min_delta;

static int hf_nan_attr_ranging_setup_ftm_max_burst_duration;

static int hf_nan_attr_ranging_setup_ftm_format_bw;

static int hf_nan_attr_ftm_range_report;

static int hf_nan_attr_cipher_suite_capabilities;

static int hf_nan_attr_cipher_suite_capabilities_ndtksa_nmtksa_replay_counters;

static int hf_nan_attr_cipher_suite_capabilities_gtksa_igtksa_bigtksa_support;

static int hf_nan_attr_cipher_suite_capabilities_gtksa_replay_counters;

static int hf_nan_attr_cipher_suite_capabilities_igtksa_bigtksa_cipher;

static int hf_nan_attr_cipher_suite_id;

static int hf_nan_attr_security_context_identifier;

static int hf_nan_attr_security_context_identifier_len;

static int hf_nan_attr_security_context_identifier_type;

static int hf_nan_attr_shared_key_rsna_descriptor;

static int hf_nan_attr_vendor_specific_body;

static int hf_nan_attr_container_element_id;

static int hf_nan_attr_container_element_len;

/* Device Capability Extension attribute, Capability Info field */

static int hf_nan_attr_device_capability_extension;

static int hf_nan_attr_device_capability_extension_6g_regulatory_info_presented;

static int hf_nan_attr_device_capability_extension_6g_regulatory_info;

static int hf_nan_attr_device_capability_extension_6g_regulatory_info_reserved;

static int hf_nan_attr_device_capability_extension_paring_setup_enabled;

static int hf_nan_attr_device_capability_extension_npk_nik_cache_enabled;

/* NAN Identity Resolution attribute */

static int hf_nan_attr_identity_cipher_version;

static int hf_nan_attr_identity_resolution_nonce;

static int hf_nan_attr_identity_resolution_tag;

/* NAN Pairing Bootstrapping attribute */

static int hf_nan_attr_pairing_bootstrapping_dialog_token;

static int hf_nan_attr_pairing_bootstrapping_type_status;

static int hf_nan_attr_pairing_bootstrapping_type;

static int hf_nan_attr_pairing_bootstrapping_status;

static int hf_nan_attr_pairing_bootstrapping_resaon_code;

static int hf_nan_attr_pairing_bootstrapping_comeback_after;

static int hf_nan_attr_pairing_bootstrapping_comeback_cookie_len;

static int hf_nan_attr_pairing_bootstrapping_comeback_cookie;

static int hf_nan_attr_pairing_bootstrapping_methods;

static int hf_nan_attr_pairing_bootstrapping_method_opportunistic_bootstrapping;

static int hf_nan_attr_pairing_bootstrapping_method_pin_code_display;

static int hf_nan_attr_pairing_bootstrapping_method_passphrase_display;

static int hf_nan_attr_pairing_bootstrapping_method_qr_code_display;

static int hf_nan_attr_pairing_bootstrapping_method_nfc_tag;

static int hf_nan_attr_pairing_bootstrapping_method_keypad_pin_code_only;

static int hf_nan_attr_pairing_bootstrapping_method_keypad_passphrase;

static int hf_nan_attr_pairing_bootstrapping_method_qr_code_scan;

static int hf_nan_attr_pairing_bootstrapping_method_nfc_reader;

static int hf_nan_attr_pairing_bootstrapping_method_reserved;

static int hf_nan_attr_pairing_bootstrapping_method_service_managed_bootstrapping;

static int hf_nan_attr_pairing_bootstrapping_method_bootstrapping_handshakes_skipped;

static int hf_nan_attr_reserved;

enum {

    NAN_ATTR_MASTER_INDICATION = 0x00,

    NAN_ATTR_CLUSTER = 0x01,

    NAN_ATTR_SERVICE_ID_LIST = 0x02,

    NAN_ATTR_SERVICE_DESCRIPTOR = 0x03,

    NAN_ATTR_CONNECTION_CAPABILITY = 0x04,

    NAN_ATTR_WLAN_INFRA = 0x05,

    NAN_ATTR_P2P_OPERATION = 0x06,

    NAN_ATTR_IBSS = 0x07,

    NAN_ATTR_MESH = 0x08,

    NAN_ATTR_FURTHER_SERVICE_DISCOVERY = 0x09,

    NAN_ATTR_FURTHER_AVAILABILITY_MAP = 0x0A,

    NAN_ATTR_COUNTRY_CODE = 0x0B,

    NAN_ATTR_RANGING = 0x0C,

    NAN_ATTR_CLUSTER_DISCOVERY = 0x0D,

    NAN_ATTR_SERVICE_DESCRIPTOR_EXTENSION = 0x0E,

    NAN_ATTR_DEVICE_CAPABILITY = 0x0F,

    NAN_ATTR_NDP = 0x10,

    NAN_ATTR_RESERVED_NMSG = 0x11,

    NAN_ATTR_AVAILABILITY = 0x12,

    NAN_ATTR_NDC = 0x13,

    NAN_ATTR_NDL = 0x14,

    NAN_ATTR_NDL_QOS = 0x15,

    NAN_ATTR_RESERVED_MULTICAST_SCHEDULE = 0x16,

    NAN_ATTR_UNALIGNED_SCHEDULE = 0x17,

    NAN_ATTR_RESERVED_UNICAST_PAGING = 0x18,

    NAN_ATTR_RESERVED_MULTICAST_PAGING = 0x19,

    NAN_ATTR_RANGING_INFORMATION = 0x1A,

    NAN_ATTR_RANGING_SETUP = 0x1B,

    NAN_ATTR_FTM_RANGING_REPORT = 0x1C,

    NAN_ATTR_ELEMENT_CONTAINER = 0x1D,

    NAN_ATTR_EXTENDED_WLAN_INFRA = 0x1E,

    NAN_ATTR_EXTENDED_P2P_OPERATION = 0x1F,

    NAN_ATTR_EXTENDED_IBSS = 0x20,

    NAN_ATTR_EXTENDED_MESH = 0x21,

    NAN_ATTR_CIPHER_SUITE_INFO = 0x22,

    NAN_ATTR_SECURITY_CONTEXT_INFO = 0x23,

    NAN_ATTR_SHARED_KEY_DESCRIPTOR = 0x24,

    NAN_ATTR_RESERVED_MULTICAST_SCHEDULE_CHANGE = 0x25,

    NAN_ATTR_RESERVED_MULTICAST_SCHEDULE_OWNER_CHANGE = 0x26,

    NAN_ATTR_PUBLIC_AVAILABILITY = 0x27,

    NAN_ATTR_SUBSCRIBE_SERVICE_ID_LIST = 0x28,

    NAN_ATTR_NDP_EXTENSION = 0x29,

    NAN_ATTR_DEVICE_CAPABILITY_EXTENSION = 0x2a,

    NAN_ATTR_IDENTITY_RESOLUTION = 0x2b,

    NAN_ATTR_PAIRING_BOOTSTRAPPING = 0x2c,

    NAN_ATTR_VENDOR_SPECIFIC = 0xDD

};

static const value_string attribute_types[] = {

    { NAN_ATTR_MASTER_INDICATION, "Master Indication Attribute" },

    { NAN_ATTR_CLUSTER, "Cluster Attribute" },

    { NAN_ATTR_SERVICE_ID_LIST, "Service ID List Attribute" },

    { NAN_ATTR_SERVICE_DESCRIPTOR, "Service Descriptor Attribute" },

    { NAN_ATTR_CONNECTION_CAPABILITY, "NAN Connection Capability Attribute" },

    { NAN_ATTR_WLAN_INFRA, "WLAN Infrastructure Attribute" },

    { NAN_ATTR_P2P_OPERATION, "P2P Operation Attribute" },

    { NAN_ATTR_IBSS, "IBSS Attribute" },

    { NAN_ATTR_MESH, "Mesh Attribute" },

    { NAN_ATTR_FURTHER_SERVICE_DISCOVERY, "Further NAN Service Discovery Attribute" },

    { NAN_ATTR_FURTHER_AVAILABILITY_MAP, "Further Availability Map Attribute" },

    { NAN_ATTR_COUNTRY_CODE, "Country Code Attribute" },

    { NAN_ATTR_RANGING, "Ranging Attribute" },

    { NAN_ATTR_CLUSTER_DISCOVERY, "Cluster Discovery Attribute" },

    { NAN_ATTR_SERVICE_DESCRIPTOR_EXTENSION, "Service Descriptor Extension Attribute" },

    { NAN_ATTR_DEVICE_CAPABILITY, "Device Capability" },

    { NAN_ATTR_NDP, "NDP Attribute" },

    { NAN_ATTR_RESERVED_NMSG, "Reserved (NMSG)" },

    { NAN_ATTR_AVAILABILITY, "NAN Availability" },

    { NAN_ATTR_NDC, "NDC Attribute" },

    { NAN_ATTR_NDL, "NDL Attribute" },

    { NAN_ATTR_NDL_QOS, "NDL QoS Attribute" },

    { NAN_ATTR_RESERVED_MULTICAST_SCHEDULE, "Reserved (Multicast Schedule)" },

    { NAN_ATTR_UNALIGNED_SCHEDULE, "Unaligned Schedule Attribute" },

    { NAN_ATTR_RESERVED_UNICAST_PAGING, "Reserved (Unicast Paging)" },

    { NAN_ATTR_RESERVED_MULTICAST_PAGING, "Reserved (Multicast Paging)" },

    { NAN_ATTR_RANGING_INFORMATION, "Ranging Information Attribute" },

    { NAN_ATTR_RANGING_SETUP, "Ranging Setup Attribute" },

    { NAN_ATTR_FTM_RANGING_REPORT, "FTM Ranging Report Attribute" },

    { NAN_ATTR_ELEMENT_CONTAINER, "Element Container Attribute" },

    { NAN_ATTR_EXTENDED_WLAN_INFRA, "Extended WLAN Infrastructure Attribute" },

    { NAN_ATTR_EXTENDED_P2P_OPERATION, "Extended P2P Operation Attribute" },

    { NAN_ATTR_EXTENDED_IBSS, "Extended IBSS Attribute" },

    { NAN_ATTR_EXTENDED_MESH, "Extended Mesh Attribute" },

    { NAN_ATTR_CIPHER_SUITE_INFO, "Cipher Suite Info Attribute" },

    { NAN_ATTR_SECURITY_CONTEXT_INFO, "Security Context Info Attribute" },

    { NAN_ATTR_SHARED_KEY_DESCRIPTOR, "Shared-Key Descriptor Attribute" },

    { NAN_ATTR_RESERVED_MULTICAST_SCHEDULE_CHANGE, "Reserved (Multicast Schedule Change)" },

    { NAN_ATTR_RESERVED_MULTICAST_SCHEDULE_OWNER_CHANGE, "Reserved (Multicast Schedule Owner Change)" },

    { NAN_ATTR_PUBLIC_AVAILABILITY, "Public Availability Attribute" },

    { NAN_ATTR_SUBSCRIBE_SERVICE_ID_LIST, "Subscribe Service ID List Attribute" },

    { NAN_ATTR_NDP_EXTENSION, "NDP Extension Attribute" },

    { NAN_ATTR_DEVICE_CAPABILITY_EXTENSION, "Device Capability Extension"},

    { NAN_ATTR_IDENTITY_RESOLUTION, "NAN Identity Resolution"},

    { NAN_ATTR_PAIRING_BOOTSTRAPPING, "NAN Pairing Bootstrapping"},

    { NAN_ATTR_VENDOR_SPECIFIC, "Vendor Specific Attribute" },

    { 0, NULL }

};

// Bitmask fields shared by multiple attributes

static int* const map_control_fields[] = {

    &hf_nan_map_ctrl_map_id,

    &hf_nan_map_ctrl_availability_interval_duration,

    &hf_nan_map_ctrl_repeat,

    NULL

};

static int* const time_bitmap_ctr_fields[] = {

    &hf_nan_time_bitmap_ctrl_bit_duration,

    &hf_nan_time_bitmap_ctrl_period,

    &hf_nan_time_bitmap_ctrl_start_offset,

    NULL

};

static const true_false_string srf_type_flags = {

    "Address Set is a Bloom filter",

    "Address Set is a sequence of MAC Addresses"

};

static const true_false_string srf_include_flags = {

    "Only STAs Present in Address Set shall send a response",

    "STAs present in Address Set shall not send responses"

};

static const true_false_string sdea_ctr_data_path_type_flags = {

    "Reserved",

    "Unicast NDP required (Reserved if NDP is not required)"

};

static const true_false_string sdea_ctr_reserved_multicast_type_flags = {

    "Many to many (Reserved if NDP is not required)",

    "One to many (Reserved if NDP is not required)"

};

static const true_false_string device_cap_map_id_apply_to_flags = {

    "Only specified map",

    "All maps"

};

static const true_false_string device_cap_op_mode_phy_flags_vht = {

    "VHT",

    "HT"

};

static const true_false_string device_cap_op_mode_phy_flags_he = {

    "HE",

    "HE Not Supported"

};

static const true_false_string availability_entry_entries_type_flags = {

    "Operating Classes and channel entries",

    "Indicated bands"

};

static const true_false_string ndc_ctr_selected_flags = {

    "Selected NDC for a NDL Schedule",

    "NDC included for the peer's information"

};

static const value_string map_ctrl_availability_interval_duration[] = {

    { 0, "16 TU" },

    { 1, "32 TU" },

    { 2, "64 TU" },

    { 3, "Reserved" },

    { 0, NULL }

};

static const value_string service_ctr_type[] = {

    { 0, "Publish" },

    { 1, "Subscribe" },

    { 2, "Follow up" },

    { 3, "Reserved" },

    { 0, NULL }

};

static const range_string service_info_protocol_type[] = {

    { 0, 0, "Reserved" },

    { 1, 1, "Bonjour" },

    { 2, 2, "Generic" },

    { 3, 255, "Reserved" },

    { 0, 0, NULL }

};

static const value_string availability_entry_type[] = {

    { 0, "Reserved" },

    { 1, "Committed" },

    { 2, "Potential" },

    { 3, "Committed + Potential" },

    { 4, "Conditional" },

    { 5, "Reserved" },

    { 6, "Potential + Conditional" },

    { 7, "Reserved" },

    { 0, NULL }

};

static const range_string availability_entry_time_bitmap_ctr_bit_duration_type[] = {

    { 0, 0, "16 TU" },

    { 1, 1, "32 TU" },

    { 2, 2, "64 TU" },

    { 3, 3, "128 TU" },

    { 4, 7, "Reserved" },

    { 0, 0, NULL }

};

static const value_string availability_entry_time_bitmap_ctr_period_type[] = {

    { 1, "128 TU" },

    { 2, "256 TU" },

    { 3, "512 TU" },

    { 4, "1024 TU" },

    { 5, "2048 TU" },

    { 6, "4096 TU" },

    { 7, "8192 TU" },

    { 0, NULL }

};

static const range_string availability_entry_entries_band_type[] = {

    { 0, 0, "Reserved (for TV white spaces)" },

    { 1, 1, "Sub-1 GHz" },

    { 2, 2, "2.4 GHz" },

    { 3, 3, "Reserved (for 3.6 GHz)" },

    { 4, 4, "4.9 and 5 GHz" },

    { 5, 5, "Reserved (for 60 GHz)" },

    { 6, 6, "Reserved (for 45 GHz)" },

    { 7, 7, "6 Ghz" },

    { 8, 255, "Reserved" },

    { 0, 0, NULL }

};

static const range_string ndp_type_values[] = {

    { 0, 0, "Request" },

    { 1, 1, "Response" },

    { 2, 2, "Confirm" },

    { 3, 3, "Security Install" },

    { 4, 4, "Terminate" },

    { 5, 15, "Reserved" },

    { 0, 0, NULL }

};

static const range_string ndpe_tlv_type_values[] = {

    { 0, 0, "IPv6 Link Local" },

    { 1, 1, "Service Info" },

    { 2, 255, "Reserved" },

    { 0, 0, NULL }

};

static const range_string ndl_type_values[] = {

    { 0, 0, "Request" },

    { 1, 1, "Response" },

    { 2, 2, "Confirm" },

    { 3, 15, "Reserved" },

    { 0, 0, NULL }

};

static const range_string ranging_setup_type_values[] = {

    { 0, 0, "Request" },

    { 1, 1, "Response" },

    { 2, 2, "Termination" },

    { 3, 15, "Reserved" },

    { 0, 0, NULL }

};

static const range_string status_type1_values[] = {

    { 0, 0, "Continue" },

    { 1, 1, "Accepted" },

    { 2, 2, "Rejected" },

    { 3, 15, "Reserved" },

    { 0, 0, NULL }

};

static const range_string status_type2_values[] = {

    { 0, 0, "Accepted" },

    { 1, 1, "Rejected" },

    { 2, 15, "Reserved" },

    { 0, 0, NULL }

};

static const range_string reason_code_values[] = {

    { 0, 0, "Reserved" },

    { 1, 1, "UNSPECIFIED_REASON" },

    { 2, 2, "RESOURCE_LIMITATION" },

    { 3, 3, "INVALID_PARAMETERS" },

    { 4, 4, "FTM_PARAMETERS_INCAPABLE" },

    { 5, 5, "NO_MOVEMENT" },

    { 6, 6, "INVALID_AVAILABILITY" },

    { 7, 7, "IMMUTABLE_UNACCEPTABLE" },

    { 8, 8, "SECURITY_POLICY" },

    { 9, 9, "QoS_UNACCEPTABLE" },

    { 10, 10, "NDP_REJECTED" },

    { 11, 11, "NDL_UNACCEPTABLE" },

    { 12, 12, "Ranging Schedule unacceptable" },

    { 13, 255, "Reserved" },

    { 0, 0, NULL }

};

static const range_string action_frame_type_values[] = {

    { 0, 0, "Reserved" },

    { 1, 1, "Ranging Request" },

    { 2, 2, "Ranging Response" },

    { 3, 3, "Ranging Termination" },

    { 4, 4, "Ranging Report" },

    { 5, 5, "Data Path Request" },

    { 6, 6, "Data Path Response" },

    { 7, 7, "Data Path Confirm" },

    { 8, 8, "Data Path Key Installment" },

    { 9, 9, "Data Path Termination" },

    { 10, 10, "Schedule Request" },

    { 11, 11, "Schedule Response" },

    { 12, 12, "Schedule Confirm" },

    { 13, 13, "Schedule Update Notification" },

    { 14, 255, "Reserved" },

    { 0, 0, NULL }

};

static const value_string ndl_type_string[] = {

    { 0, "S-NDL" },

    { 1, "Reserved (P-NDL)" },

    { 0, NULL }

};

static const value_string ndl_setup_reason[] = {

    { 0, "NDP" },

    { 1, "FSD using GAS" },

    { 2, "Reserved" },

    { 3, "Reserved" },

    { 0, NULL }

};

static const value_string unaligned_sch_ulw_type[] = {

    { 0, "Followed by a Band ID field" },

    { 1, "Followed by a Channel Entry field without Auxiliary Channel" },

    { 2, "Followed by a Channel Entry field with Auxiliary Channel" },

    { 3, "Reserved" },

    { 0, NULL }

};

static const range_string security_context_iden_type[] = {

    { 0, 0, "Reserved" },

    { 1, 1, "ND-PMKID" },

    { 2, 255, "Reserved" },

    { 0, 0, NULL }

};

static const value_string device_role[] = {

    { 0, "AP" },

    { 1, "Non-AP STA associated with AP" },

    { 2, "Non-AP STA listening to AP" },

    { 0, NULL }

};

static const range_string furth_av_map_id[] = {

    {0, 15, "Identify Further Availability attribute"},

    {16, 255, "Reserved"},

    {0, 0, NULL}

};

static const value_string device_capability_extension_6g_regulatoty_info[] = {

    { 0, "Indoor AP" },

    { 1, "Standard Power AP" },

    { 2, "Very Low Power AP" },

    { 3, "Indoor Enabled AP" },

    { 4, "Indoor Standard Power AP" },

    { 0, NULL }

};

static const range_string nan_identity_resolution_cipher_version[] = {

    {0, 0, "128-bit NIK, 64-bit Nonce, 64-bit Tag, HMAC-SHA-256"},

    {1, 255, "Reserved"},

    {0, 0, NULL }

};

static const value_string nan_pairing_bootstrapping_pairing_bootstrapping_type[] = {

    { 0, "Advertise" },

    { 1, "Request" },

    { 2, "Response" },

    { 0, NULL } /* Reserved for other value */

};

static const value_string nan_pairing_bootstrapping_pairing_bootstrapping_status[] = {

    { 0, "Accepted" },

    { 1, "Rejected" },

    { 2, "Comeback" },

    { 0, NULL } /* Reserved for other value */

};

static const value_string cipher_suite_capabilities_nd_nm_tksa_replay_counters[] = {

    { 0, "4 ND-TKSA and NM-TKSA (if applicable) replay counters" },

    { 1, "16 ND-TKSA and NM-TKSA (if applicable) replay counters" },

    { 0, NULL }

};

static const value_string cipher_suite_capabilities_group_and_integrity_sa_support[] = {

    { 0, "GTKSA, IGTKSA, BIGTKSA are not supported" },

    { 1, "GTKSA and IGTKSA are supported, and BIGTKSA is not supported" },

    { 2, "GTKSA, IGTKSA, and BIGTKSA are supported" },

    { 3, "Reserved" },

    { 0, NULL }

};

static const value_string cipher_suite_capabilities_gtksa_replay_counters[] = {

    { 0, "4 GTKSA replay counters" },

    { 1, "16 GTKSA replay counters" },

    { 0, NULL }

};

static const value_string cipher_suite_capabilities_integrity_sa_ciphers[] = {

    { 0, "NCS-BIP-128 (BIP-CMAC-128)" },

    { 1, "NCS-BIP_256 (BIP-GMAC-256)" },

    { 0, NULL }

};

#define PACKET_WIFI_NAN_MAX_CHANNEL_SET_LEN (64)

typedef struct _range_channel_set {

    uint32_t   value_min;

    uint32_t   value_max;

    const int channel_set[PACKET_WIFI_NAN_MAX_CHANNEL_SET_LEN];

} range_channel_set;

static const int *

rval_to_channel_set(const uint32_t val, const range_channel_set* ra)

{

    int i = 0;

    if (ra)

    {

        while (*ra[i].channel_set) /* no such thing as channel 0 - end of list */

        {

            if ((val >= ra[i].value_min) && (val <= ra[i].value_max))

            {

                return ra[i].channel_set;

            }

            i++;

        }

    }

    return NULL;

}

static unsigned int channel_number_valid(const uint8_t channel_number, const int *const channel_set)

{

    for (unsigned int i = 0; i < PACKET_WIFI_NAN_MAX_CHANNEL_SET_LEN; i++)

    {

        if (channel_set[i] == channel_number)

        {

            return i;

        }

    }

    return PACKET_WIFI_NAN_MAX_CHANNEL_SET_LEN;

}

// TODO: this table corresponds to the 802.11 global operating classes.

//   it's probably in the 802.11 dissector somewhere and ideally this

//   should be used instead...

static const range_channel_set op_class_channel[] = {

    {1, 80, {-1}},

    {81, 81, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}},

    {82, 82, {14}},

    {83, 83, {1, 2, 3, 4, 5, 6, 7, 8, 9}},

    {84, 84, {5, 6, 7, 8, 9, 10, 11, 12, 13}},

    {85, 85, {-3}},

    {86, 86, {-3}},

    {87, 87, {-3}},

    {88, 93, {-1}},

    {94, 94, {133, 137}},

    {95, 95, {136, 138}},

    {96, 96, {131, 132, 133, 134, 135, 136, 137, 138}},

    {97, 100, {-1}},

    {101, 101, {21, 25}},

    {102, 102, {11, 13, 15, 17, 19}},

    {103, 103, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}},

    {104, 104, {184, 192}},

    {105, 105, {188, 196}},

    {106, 106, {191, 195}},

    {107, 107, {189, 191, 193, 195, 197}},

    {108, 108, {188, 189, 190, 191, 192, 193, 194, 195, 196, 197}},

    {109, 109, {184, 188, 192, 196}},

    {110, 110, {183, 184, 185, 186, 187, 188, 189}},

    {111, 111, {182, 183, 184, 185, 186, 187, 188, 189}},

    {112, 112, {8, 12, 16}},

    {113, 113, {7, 8, 9, 10, 11}},

    {114, 114, {6, 7, 8, 9, 10, 11}},

    {115, 115, {36, 40, 44, 48}},

    {116, 116, {36, 44}},

    {117, 117, {40, 48}},

    {118, 118, {52, 56, 60, 64}},

    {119, 119, {52, 60}},

    {120, 120, {56, 64}},

    {121, 121, {100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144}},

    {122, 122, {100, 108, 116, 124, 132, 140}},

    {123, 123, {103, 112, 120, 128, 136, 144}},

    {124, 124, {149, 153, 157, 161}},

    {125, 125, {149, 153, 157, 161,165, 169}},

    {126, 126, {149, 157}},

    {127, 127, {153, 161}},

    {128, 128, {42, 58, 106, 122, 138, 155}},

    {129, 129, {50, 114}},

    {130, 130, {42, 58, 106, 122, 138, 155}},

    {131, 131, {1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53, 57, 61, 65, 69, 73, 77, 81, 85, 89, 93, 97, 101, 105, 109, 113, 117, 121, 125, 129, 133, 137, 141, 145, 149, 153, 157, 161, 165, 169, 173, 177, 181, 185, 189, 193, 197, 201, 205, 209, 213, 217, 221, 225, 229, 233}},

    {132, 132, {3, 11, 19, 27, 35, 43, 51, 59, 67, 75, 83, 91, 99, 107, 115, 123, 131, 139, 147, 155, 163, 171, 179, 187, 195, 203, 211, 219, 227}},

    {133, 133, {7, 23, 39, 55, 71, 87, 103, 119, 135, 151, 167, 183, 199, 215}},

    {134, 134, {15, 47, 79, 111, 143, 175, 207}},

    {135, 135, {7, 23, 39, 55, 71, 87, 103, 119, 135, 151, 167, 183, 199, 215}},

    {137, 137, {31, 63, 95, 127, 159, 191}},

    {138, 179, {-1}},

    {137, 179, {-1}},

    {180, 180, {1, 2, 3, 4, 5, 6}},

    {181, 191, {-1}},

    {192, 254, {-2}},

    {255, 255, {-1}},

    {0, 0, {0}}, /* no such thing as channel 1 - end of list */

};

static const range_string op_channel_spacing[] = {

    {1, 80, "Reserved"},

    {81, 82, "25"},

    {83, 84, "40"},

    {85, 85, "6, 7, 8"},

    {86, 86, "12, 14, 16"},

    {87, 87, "24, 28, 32"},

    {88, 93, "Reserved"},

    {94, 94, "20"},

    {95, 95, "10"},

    {96, 96, "5"},

    {97, 100, "Reserved"},

    {101, 101, "20"},

    {102, 102, "10"},

    {103, 103, "5"},

    {104, 105, "40"},

    {106, 106, "20"},

    {107, 107, "10"},

    {108, 108, "5"},

    {109, 109, "20"},

    {110, 110, "10"},

    {111, 111, "5"},

    {112, 112, "20"},

    {113, 113, "10"},

    {114, 114, "5"},

    {115, 115, "20"},

    {116, 117, "40"},

    {118, 118, "20"},

    {119, 120, "40"},

    {121, 121, "20"},

    {122, 123, "40"},

    {124, 125, "20"},

    {126, 127, "40"},

    {128, 128, "80"},

    {129, 129, "160"},

    {130, 130, "80"},

    {131, 131, "20"},

    {132, 132, "40"},

    {133, 133, "80"},

    {134, 134, "160"},

    {135, 135, "80"},

    {136, 136, "20"},

    {137, 137, "320"},

    {138, 179, "Reserved"},

    {180, 180, "2160"},

    {181, 191, "Reserved"},

    {255, 255, "Reserved"},

    {0, 0, NULL}

};

static const range_string op_starting_freq[] = {

    {1, 80, "Reserved"},

    {81, 81, "2.407"},

    {82, 82, "2.414"},

    {83, 83, "2.407"},

    {84, 84, "2.407"},

    {88, 93, "Reserved"},

    {94, 95, "3"},

    {96, 96, "3.0025"},

    {97, 100, "Reserved"},

    {101, 101, "4.85"},

    {102, 102, "4.89"},

    {103, 103, "4.9375"},

    {104, 104, "4"},

    {105, 107, "4"},

    {108, 108, "4.0025"},

    {109, 110, "4"},

    {111, 111, "4.0025"},

    {112, 113, "5"},

    {114, 114, "5.0025"},

    {115, 130, "5"},

    {131, 135, "5.950"},

    {136, 136, "5.925"},

    {137, 137, "5.950"},

    {138, 179, "Reserved"},

    {180, 180, "56.16"},

    {181, 191, "Reserved"},

    {255, 255, "Reserved"},

    {0, 0, NULL}

};

static void

dissect_attr_master_indication(proto_tree* attr_tree, tvbuff_t* tvb, int offset, uint16_t attr_len, packet_info* pinfo)

{

    if (attr_len != NAN_MASTER_IND_LENGTH)

    {

        expert_add_info(pinfo, attr_tree, &ei_nan_elem_len_invalid);

        return;

    }

    proto_tree_add_item(attr_tree, hf_nan_attr_master_preference, tvb,

        offset + 3, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(attr_tree, hf_nan_attr_master_random_factor, tvb,

        offset + 4, 1, ENC_BIG_ENDIAN);

}

static void

dissect_attr_cluster(proto_tree* attr_tree, tvbuff_t* tvb, int offset, uint16_t attr_len, packet_info* pinfo)

{

    if (attr_len != NAN_CLUSTER_LENGTH)

    {

        expert_add_info(pinfo, attr_tree, &ei_nan_elem_len_invalid);

        return;

    }

    proto_tree* anchor_master_tree = proto_tree_add_subtree(attr_tree, tvb, offset + 3, 13,

        ett_cluster_anchor_master_info, NULL, "Anchor Master Information");

    proto_tree_add_item(anchor_master_tree, hf_nan_attr_cluster_anchor_master_rank, tvb,

        offset + 3, 8, ENC_BIG_ENDIAN);

    proto_tree_add_item(anchor_master_tree, hf_nan_attr_cluster_hop_count, tvb,

        offset + 11, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(anchor_master_tree, hf_nan_attr_cluster_beacon_transmission_time, tvb,

        offset + 12, 4, ENC_LITTLE_ENDIAN);

}

static void

dissect_attr_service_id_list(proto_tree* attr_tree, tvbuff_t* tvb, int offset, uint16_t attr_len, packet_info* pinfo)

{

    if (attr_len % 6 != 0 || attr_len == 0)

    {

        expert_add_info_format(pinfo, attr_tree, &ei_nan_elem_len_invalid, "Invalid Service ID length");

        return;

    }

    int num_service_ids = attr_len / 6;

    offset += 3;

    for (int i = 1; i <= num_service_ids; ++i)

    {

        proto_tree_add_item(attr_tree, hf_nan_service_id, tvb, offset, 6, ENC_NA);

        offset += 6;

    }

}

static void

dissect_attr_sda(proto_tree* attr_tree, tvbuff_t* tvb, int offset, uint16_t attr_len, packet_info* pinfo)

{

    if (attr_len < NAN_SDA_MIN_LENGTH)

    {

        expert_add_info(pinfo, attr_tree, &ei_nan_elem_len_invalid);

        return;

    }

    proto_tree_add_item(attr_tree, hf_nan_service_id, tvb,

        offset + 3, 6, ENC_NA);

    proto_tree_add_item(attr_tree, hf_nan_instance_id, tvb,

        offset + 9, 1, ENC_BIG_ENDIAN);

    proto_tree_add_item(attr_tree, hf_nan_attr_sda_requestor_instance_id, tvb,

        offset + 10, 1, ENC_BIG_ENDIAN);

    offset += 11;

    static int* const service_ctr_fields[] = {

        &hf_nan_attr_sda_sc_type,

        &hf_nan_attr_sda_sc_matching_filter,

        &hf_nan_attr_sda_sc_service_response,

        &hf_nan_attr_sda_sc_service_info,

        &hf_nan_attr_sda_sc_discovery_range,

        &hf_nan_attr_sda_sc_binding_bitmap,

        NULL

    };

    proto_tree_add_bitmask(attr_tree, tvb, offset, hf_nan_attr_sda_sc,

        ett_sda_service_ctr, service_ctr_fields, ENC_LITTLE_ENDIAN);

    uint8_t service_ctr_byte = tvb_get_uint8(tvb, offset);

    offset += 1;

    const uint8_t BITMASK_TYPE_SUBSCRIBE = 0x01;

    const uint8_t BITMASK_TYPE_FOLLOW_UP = 0x02;

    const uint8_t BITMASK_MATCHING_FILTER_PRESENT = 0x04;

    const uint8_t BITMASK_SERVICE_RESPONSE_FILTER_PRESENT = 0x08;

    const uint8_t BITMASK_SERVICE_INFO_PRESENT = 0x10;

    const uint8_t BITMASK_BITMAP_PRESENT = 0x40;

    if (service_ctr_byte & BITMASK_TYPE_SUBSCRIBE)

    {

        col_prepend_fstr(pinfo->cinfo, COL_INFO, "SDF Subscribe, ");

    }