osmocom
/
wireshark
11
0
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity

tools/check_typed_item_calls: check FT_BOOLEAN mask length

This commit is contained in:
Martin Mathieson 2022-12-15 13:28:05 +00:00
parent 1e8d3d8695
commit d17c018013
31 changed files with 411 additions and 381 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
epan/dissectors/packet-a21.c
View File

@ -1124,7 +1124,7 @@ void proto_register_a21(void)
},
{ &hf_a21_ch_rec_ch_num,
{ "Channel Number", "a21.ch_channel_number",
FT_UINT16, BASE_DEC, NULL, 0x7ff,
FT_UINT16, BASE_DEC, NULL, 0x07ff,
NULL, HFILL }
},

16
epan/dissectors/packet-afp.c
View File

@ -6705,17 +6705,17 @@ proto_register_afp(void)
{ &hf_afp_user_bitmap_UID,
{ "User ID", "afp.user_bitmap.UID",
FT_BOOLEAN, 16, NULL, 0x01,
FT_BOOLEAN, 16, NULL, 0x0001,
NULL, HFILL }},
{ &hf_afp_user_bitmap_GID,
{ "Primary group ID", "afp.user_bitmap.GID",
FT_BOOLEAN, 16, NULL, 0x02,
FT_BOOLEAN, 16, NULL, 0x0002,
NULL, HFILL }},
{ &hf_afp_user_bitmap_UUID,
{ "UUID", "afp.user_bitmap.UUID",
FT_BOOLEAN, 16, NULL, 0x04,
FT_BOOLEAN, 16, NULL, 0x0004,
NULL, HFILL }},
{ &hf_afp_message_type,
@ -6734,12 +6734,12 @@ proto_register_afp(void)
*/
{ &hf_afp_message_bitmap_REQ,
{ "Request message", "afp.message_bitmap.requested",
FT_BOOLEAN, 16, NULL, 0x01,
FT_BOOLEAN, 16, NULL, 0x0001,
"Message Requested", HFILL }},
{ &hf_afp_message_bitmap_UTF,
{ "Message is UTF-8", "afp.message_bitmap.utf8",
FT_BOOLEAN, 16, NULL, 0x02,
FT_BOOLEAN, 16, NULL, 0x0002,
NULL, HFILL }},
{ &hf_afp_message_len,
@ -6764,17 +6764,17 @@ proto_register_afp(void)
{ &hf_afp_extattr_bitmap_NoFollow,
{ "No follow symlinks", "afp.extattr_bitmap.nofollow",
FT_BOOLEAN, 16, NULL, 0x01,
FT_BOOLEAN, 16, NULL, 0x0001,
"Do not follow symlink", HFILL }},
{ &hf_afp_extattr_bitmap_Create,
{ "Create", "afp.extattr_bitmap.create",
FT_BOOLEAN, 16, NULL, 0x02,
FT_BOOLEAN, 16, NULL, 0x0002,
"Create extended attribute", HFILL }},
{ &hf_afp_extattr_bitmap_Replace,
{ "Replace", "afp.extattr_bitmap.replace",
FT_BOOLEAN, 16, NULL, 0x04,
FT_BOOLEAN, 16, NULL, 0x0004,
"Replace extended attribute", HFILL }},
{ &hf_afp_extattr_namelen,

10
epan/dissectors/packet-afs.c
View File

@ -3424,13 +3424,13 @@ proto_register_afs(void)
FT_UINT32, BASE_HEX, 0, 0, NULL, HFILL }},
{ &hf_afs_vldb_flags_rwexists, { "Read/Write Exists", "afs.vldb.flags.rwexists",
FT_BOOLEAN, 32, 0, 0x1000, NULL, HFILL }},
FT_BOOLEAN, 32, 0, 0x00001000, NULL, HFILL }},
{ &hf_afs_vldb_flags_roexists, { "Read-Only Exists", "afs.vldb.flags.roexists",
FT_BOOLEAN, 32, 0, 0x2000, NULL, HFILL }},
FT_BOOLEAN, 32, 0, 0x00002000, NULL, HFILL }},
{ &hf_afs_vldb_flags_bkexists, { "Backup Exists", "afs.vldb.flags.bkexists",
FT_BOOLEAN, 32, 0, 0x4000, NULL, HFILL }},
FT_BOOLEAN, 32, 0, 0x00004000, NULL, HFILL }},
{ &hf_afs_vldb_flags_dfsfileset, { "DFS Fileset", "afs.vldb.flags.dfsfileset",
FT_BOOLEAN, 32, 0, 0x8000, NULL, HFILL }},
FT_BOOLEAN, 32, 0, 0x00008000, NULL, HFILL }},
{ &hf_afs_vldb_spare1, { "Spare 1", "afs.vldb.spare1",
FT_UINT32, BASE_DEC, 0, 0, NULL, HFILL }},
@ -3490,7 +3490,7 @@ proto_register_afs(void)
{ &hf_afs_cm_capabilities, { "Capabilities", "afs.cm.capabilities",
FT_UINT32, BASE_HEX, 0, 0, NULL, HFILL }},
{ &hf_afs_cm_cap_errortrans, { "ERRORTRANS", "afs.cm.capabilities.errortrans",
FT_BOOLEAN, 32, 0, 0x0001, NULL, HFILL }},
FT_BOOLEAN, 32, 0, 0x00000001, NULL, HFILL }},
/* PROT Server Fields */
{ &hf_afs_prot_errcode, { "Error Code", "afs.prot.errcode",

4
epan/dissectors/packet-aim.c
View File

@ -4136,10 +4136,10 @@ proto_register_aim(void)
{ "Privilege flags", "aim_generic.privilege_flags", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL },
},
{ &hf_generic_allow_idle_see,
{ "Allow other users to see idle time", "aim_generic.privilege_flags.allow_idle", FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x0001, NULL, HFILL },
{ "Allow other users to see idle time", "aim_generic.privilege_flags.allow_idle", FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x00000001, NULL, HFILL },
},
{ &hf_generic_allow_member_see,
{ "Allow other users to see how long account has been a member", "aim_generic.privilege_flags.allow_member", FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x0002, NULL, HFILL },
{ "Allow other users to see how long account has been a member", "aim_generic.privilege_flags.allow_member", FT_BOOLEAN, 32, TFS(&tfs_set_notset), 0x00000002, NULL, HFILL },
},
{ &hf_generic_selfinfo_warninglevel,
{ "Warning level", "aim_generic.selfinfo.warn_level", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL },

10
epan/dissectors/packet-ansi_801.c
View File

@ -1771,7 +1771,7 @@ proto_register_ansi_801(void)
/* Generated from convert_proto_tree_add_text.pl */
{ &hf_ansi_801_desired_pilot_phase_resolution,
{ "Desired pilot phase resolution", "ansi_801.desired_pilot_phase_resolution",
FT_BOOLEAN, 24, TFS(&tfs_desired_pilot_phase_resolution), 0x08,
FT_BOOLEAN, 24, TFS(&tfs_desired_pilot_phase_resolution), 0x000008,
NULL, HFILL }
},
{ &hf_ansi_801_reserved_24_7,
@ -1781,22 +1781,22 @@ proto_register_ansi_801(void)
},
{ &hf_ansi_801_for_req_loc_height_information,
{ "Height information", "ansi_801.height_incl",
FT_BOOLEAN, 24, TFS(&tfs_requested_not_requested), 0x10,
FT_BOOLEAN, 24, TFS(&tfs_requested_not_requested), 0x000010,
NULL, HFILL }
},
{ &hf_ansi_801_for_req_loc_clock_correction_for_gps_time,
{ "Clock correction for GPS time", "ansi_801.clock_correction_for_gps_time",
FT_BOOLEAN, 24, TFS(&tfs_requested_not_requested), 0x08,
FT_BOOLEAN, 24, TFS(&tfs_requested_not_requested), 0x000008,
NULL, HFILL }
},
{ &hf_ansi_801_for_req_loc_velocity_information,
{ "Velocity information", "ansi_801.velocity_information",
FT_BOOLEAN, 24, TFS(&tfs_requested_not_requested), 0x04,
FT_BOOLEAN, 24, TFS(&tfs_requested_not_requested), 0x000004,
NULL, HFILL }
},
{ &hf_ansi_801_reserved24_3,
{ "Reserved", "ansi_801.reserved",
FT_UINT24, BASE_HEX, NULL, 0x03,
FT_UINT24, BASE_HEX, NULL, 0x000003,
NULL, HFILL }
},
{ &hf_ansi_801_use_action_time_indicator,

98
epan/dissectors/packet-assa_r3.c
View File

@ -7618,37 +7618,37 @@ void proto_register_r3 (void)
},
{ &hf_r3_definetimezone_daymap0,
{ "Sunday", "r3.definetimezone.daymap.sunday",
FT_BOOLEAN, 8, TFS (&tfs_enabled_disabled), 0x00000001,
FT_BOOLEAN, 8, TFS (&tfs_enabled_disabled), 0x01,
NULL, HFILL }
},
{ &hf_r3_definetimezone_daymap1,
{ "Monday", "r3.definetimezone.daymap.monday",
FT_BOOLEAN, 8, TFS (&tfs_enabled_disabled), 0x00000002,
FT_BOOLEAN, 8, TFS (&tfs_enabled_disabled), 0x02,
NULL, HFILL }
},
{ &hf_r3_definetimezone_daymap2,
{ "Tuesday", "r3.definetimezone.daymap.tuesday",
FT_BOOLEAN, 8, TFS (&tfs_enabled_disabled), 0x00000004,
FT_BOOLEAN, 8, TFS (&tfs_enabled_disabled), 0x04,
NULL, HFILL }
},
{ &hf_r3_definetimezone_daymap3,
{ "Wednesday", "r3.definetimezone.daymap.wednesday",
FT_BOOLEAN, 8, TFS (&tfs_enabled_disabled), 0x00000008,
FT_BOOLEAN, 8, TFS (&tfs_enabled_disabled), 0x08,
NULL, HFILL }
},
{ &hf_r3_definetimezone_daymap4,
{ "Thursday", "r3.definetimezone.daymap.thursday",
FT_BOOLEAN, 8, TFS (&tfs_enabled_disabled), 0x00000010,
FT_BOOLEAN, 8, TFS (&tfs_enabled_disabled), 0x10,
NULL, HFILL }
},
{ &hf_r3_definetimezone_daymap5,
{ "Friday", "r3.definetimezone.daymap.friday",
FT_BOOLEAN, 8, TFS (&tfs_enabled_disabled), 0x00000020,
FT_BOOLEAN, 8, TFS (&tfs_enabled_disabled), 0x20,
NULL, HFILL }
},
{ &hf_r3_definetimezone_daymap6,
{ "Saturday", "r3.definetimezone.daymap.saturday",
FT_BOOLEAN, 8, TFS (&tfs_enabled_disabled), 0x00000040,
FT_BOOLEAN, 8, TFS (&tfs_enabled_disabled), 0x40,
NULL, HFILL }
},
{ &hf_r3_definetimezone_exceptiongroup,
@ -7843,82 +7843,82 @@ void proto_register_r3 (void)
},
{ &hf_r3_nvramclearoptions0,
{ "NVRAMCLEAROPTIONS_CFGINSTALLER", "r3.nvramclear.cfginstaller",
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x00000001,
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x0001,
NULL, HFILL }
},
{ &hf_r3_nvramclearoptions1,
{ "NVRAMCLEAROPTIONS_CFGADMIN", "r3.nvramclear.cfgadmin",
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x00000002,
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x0002,
NULL, HFILL }
},
{ &hf_r3_nvramclearoptions2,
{ "NVRAMCLEAROPTIONS_EXCEPTIONS", "r3.nvramclear.exceptions",
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x00000004,
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x0004,
NULL, HFILL }
},
{ &hf_r3_nvramclearoptions3,
{ "NVRAMCLEAROPTIONS_EXCEPTIONGROUPS", "r3.nvramclear.exceptiongroups",
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x00000008,
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x0008,
NULL, HFILL }
},
{ &hf_r3_nvramclearoptions4,
{ "NVRAMCLEAROPTIONS_CALENDARS", "r3.nvramclear.calendars",
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x00000010,
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x0010,
NULL, HFILL }
},
{ &hf_r3_nvramclearoptions5,
{ "NVRAMCLEAROPTIONS_TIMEZONES", "r3.nvramclear.timezones",
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x00000020,
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x0020,
NULL, HFILL }
},
{ &hf_r3_nvramclearoptions6,
{ "NVRAMCLEAROPTIONS_FILTERS", "r3.nvramclear.filters",
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x00000040,
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x0040,
NULL, HFILL }
},
{ &hf_r3_nvramclearoptions7,
{ "NVRAMCLEAROPTIONS_EVENTLOG", "r3.nvramclear.eventlog",
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x00000080,
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x0080,
NULL, HFILL }
},
{ &hf_r3_nvramclearoptions8,
{ "NVRAMCLEAROPTIONS_USERDATA", "r3.nvramclear.userdata",
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x00000100,
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x0100,
NULL, HFILL }
},
{ &hf_r3_nvramclearoptions9,
{ "NVRAMCLEAROPTIONS_DECLINEDLOG", "r3.nvramclear.declinedlog",
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x00000200,
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x0200,
NULL, HFILL }
},
{ &hf_r3_nvramclearoptions10,
{ "NVRAMCLEAROPTIONS_ALARMLOG", "r3.nvramclear.alarmlog",
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x00000400,
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x0400,
NULL, HFILL }
},
{ &hf_r3_nvramclearoptions11,
{ "NVRAMCLEAROPTIONS_LRUCACHE", "r3.nvramclear.lrucache",
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x00000800,
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x0800,
NULL, HFILL }
},
{ &hf_r3_nvramclearoptions12,
{ "NVRAMCLEAROPTIONS_DBHASH", "r3.nvramclear.dbhash",
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x00001000,
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x1000,
NULL, HFILL }
},
{ &hf_r3_nvramclearoptions13,
{ "NVRAMCLEAROPTIONS_CFGSYSTEM", "r3.nvramclear.cfgsystem",
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x00002000,
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x2000,
NULL, HFILL }
},
{ &hf_r3_nvramclearoptions14,
{ "NVRAMCLEAROPTIONS_UNUSED", "r3.nvramclear.unused",
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x00004000,
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x4000,
NULL, HFILL }
},
{ &hf_r3_nvramclearoptions15,
{ "NVRAMCLEAROPTIONS_USEBACKUP", "r3.nvramclear.usebackup",
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x00008000,
FT_BOOLEAN, 16, TFS (&tfs_enabled_disabled), 0x8000,
NULL, HFILL }
},
@ -8171,22 +8171,22 @@ void proto_register_r3 (void)
{ &hf_r3_mortisepins_s1,
{ "Mortise Pin S1", "r3.mortisepins.s1",
FT_BOOLEAN, 8, TFS (&tfs_high_low), 0x00000001,
FT_BOOLEAN, 8, TFS (&tfs_high_low), 0x01,
NULL, HFILL }
},
{ &hf_r3_mortisepins_s2,
{ "Mortise Pin S2", "r3.mortisepins.s2",
FT_BOOLEAN, 8, TFS (&tfs_high_low), 0x00000002,
FT_BOOLEAN, 8, TFS (&tfs_high_low), 0x02,
NULL, HFILL }
},
{ &hf_r3_mortisepins_s3,
{ "Mortise Pin S3", "r3.mortisepins.s3",
FT_BOOLEAN, 8, TFS (&tfs_high_low), 0x00000004,
FT_BOOLEAN, 8, TFS (&tfs_high_low), 0x04,
NULL, HFILL }
},
{ &hf_r3_mortisepins_s4,
{ "Mortise Pin S4", "r3.mortisepins.s4",
FT_BOOLEAN, 8, TFS (&tfs_high_low), 0x00000008,
FT_BOOLEAN, 8, TFS (&tfs_high_low), 0x08,
NULL, HFILL }
},
@ -8374,112 +8374,112 @@ void proto_register_r3 (void)
{ &hf_r3_lockstate_passage,
{ "Passage", "r3.lockstate.passage",
FT_BOOLEAN, 24, NULL, 0x00000001,
FT_BOOLEAN, 24, NULL, 0x000001,
NULL, HFILL }
},
{ &hf_r3_lockstate_panic,
{ "Panic", "r3.lockstate.panic",
FT_BOOLEAN, 24, NULL, 0x00000002,
FT_BOOLEAN, 24, NULL, 0x000002,
NULL, HFILL }
},
{ &hf_r3_lockstate_lockout,
{ "Lockout", "r3.lockstate.lockout",
FT_BOOLEAN, 24, NULL, 0x00000004,
FT_BOOLEAN, 24, NULL, 0x000004,
NULL, HFILL }
},
{ &hf_r3_lockstate_relock,
{ "Relock", "r3.lockstate.relock",
FT_BOOLEAN, 24, NULL, 0x00000008,
FT_BOOLEAN, 24, NULL, 0x000008,
NULL, HFILL }
},
{ &hf_r3_lockstate_autoopen,
{ "Auto Open", "r3.lockstate.autoopen",
FT_BOOLEAN, 24, NULL, 0x00000010,
FT_BOOLEAN, 24, NULL, 0x000010,
NULL, HFILL }
},
{ &hf_r3_lockstate_nextauto,
{ "Next Auto", "r3.lockstate.nextauto",
FT_BOOLEAN, 24, NULL, 0x00000020,
FT_BOOLEAN, 24, NULL, 0x000020,
NULL, HFILL }
},
{ &hf_r3_lockstate_lockstate,
{ "Lock State", "r3.lockstate.lockstate",
FT_BOOLEAN, 24, NULL, 0x00000040,
FT_BOOLEAN, 24, NULL, 0x000040,
NULL, HFILL }
},
{ &hf_r3_lockstate_wantstate,
{ "Want State", "r3.lockstate.wantstate",
FT_BOOLEAN, 24, NULL, 0x00000080,
FT_BOOLEAN, 24, NULL, 0x000080,
NULL, HFILL }
},
{ &hf_r3_lockstate_remote,
{ "Remote", "r3.lockstate.remote",
FT_BOOLEAN, 24, NULL, 0x00000100,
FT_BOOLEAN, 24, NULL, 0x000100,
NULL, HFILL }
},
{ &hf_r3_lockstate_update,
{ "Update", "r3.lockstate.update",
FT_BOOLEAN, 24, NULL, 0x00000200,
FT_BOOLEAN, 24, NULL, 0x000200,
NULL, HFILL }
},
{ &hf_r3_lockstate_exceptionspresent,
{ "Exceptions Present", "r3.lockstate.exceptionspresent",
FT_BOOLEAN, 24, NULL, 0x00000400,
FT_BOOLEAN, 24, NULL, 0x000400,
NULL, HFILL }
},
{ &hf_r3_lockstate_exceptionsactive,
{ "Exceptions Active", "r3.lockstate.exceptionsactive",
FT_BOOLEAN, 24, NULL, 0x00000800,
FT_BOOLEAN, 24, NULL, 0x000800,
NULL, HFILL }
},
{ &hf_r3_lockstate_timezonespresent,
{ "Timezones Presents", "r3.lockstate.timezonespresent",
FT_BOOLEAN, 24, NULL, 0x00001000,
FT_BOOLEAN, 24, NULL, 0x001000,
NULL, HFILL }
},
{ &hf_r3_lockstate_timezonesactive,
{ "Timezones Active", "r3.lockstate.timezonesactive",
FT_BOOLEAN, 24, NULL, 0x00002000,
FT_BOOLEAN, 24, NULL, 0x002000,
NULL, HFILL }
},
{ &hf_r3_lockstate_autounlockspresent,
{ "Auto Unlocks Present", "r3.lockstate.autounlockspresent",
FT_BOOLEAN, 24, NULL, 0x00004000,
FT_BOOLEAN, 24, NULL, 0x004000,
NULL, HFILL }
},
{ &hf_r3_lockstate_autounlocksactive,
{ "Auto Unlocks Active", "r3.lockstate.autounlocksactive",
FT_BOOLEAN, 24, NULL, 0x00008000,
FT_BOOLEAN, 24, NULL, 0x008000,
NULL, HFILL }
},
{ &hf_r3_lockstate_uapmspresent,
{ "UAPMs Present", "r3.lockstate.uapmspresent",
FT_BOOLEAN, 24, NULL, 0x00010000,
FT_BOOLEAN, 24, NULL, 0x010000,
NULL, HFILL }
},
{ &hf_r3_lockstate_uapmsactive,
{ "UAPMs Active", "r3.lockstate.uapmsactive",
FT_BOOLEAN, 24, NULL, 0x00020000,
FT_BOOLEAN, 24, NULL, 0x020000,
NULL, HFILL }
},
{ &hf_r3_lockstate_uapmrelockspresent,
{ "UAPM Relocks Present", "r3.lockstate.uapmrelockspresent",
FT_BOOLEAN, 24, NULL, 0x00040000,
FT_BOOLEAN, 24, NULL, 0x040000,
NULL, HFILL }
},
{ &hf_r3_lockstate_uapmreslocksactive,
{ "UAPM Relocks Active", "r3.lockstate.uapmreslocksactive",
FT_BOOLEAN, 24, NULL, 0x00080000,
FT_BOOLEAN, 24, NULL, 0x080000,
NULL, HFILL }
},
{ &hf_r3_lockstate_nvramprotect,
{ "NVRAM Protect", "r3.lockstate.nvramprotect",
FT_BOOLEAN, 24, NULL, 0x00100000,
FT_BOOLEAN, 24, NULL, 0x100000,
NULL, HFILL }
},
{ &hf_r3_lockstate_nvramchecksum,
{ "MVRAM Checksum", "r3.lockstate.nvramchecksum",
FT_BOOLEAN, 24, NULL, 0x00200000,
FT_BOOLEAN, 24, NULL, 0x200000,
NULL, HFILL }
},

64
epan/dissectors/packet-awdl.c
View File

@ -1634,42 +1634,42 @@ void proto_register_awdl(void)
},
{ &hf_awdl_datastate_flags_0,
{ "Infrastructure BSSID and Channel", "awdl.datastate.flags.0",
FT_BOOLEAN, 16, NULL, 0x1, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0001, NULL, HFILL
}
},
{ &hf_awdl_datastate_flags_1,
{ "Infrastructure Address", "awdl.datastate.flags.1",
FT_BOOLEAN, 16, NULL, 0x2, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0002, NULL, HFILL
}
},
{ &hf_awdl_datastate_flags_2,
{ "AWDL Address", "awdl.datastate.flags.2",
FT_BOOLEAN, 16, NULL, 0x4, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0004, NULL, HFILL
}
},
{ &hf_awdl_datastate_flags_3,
{ "Bit 3", "awdl.datastate.flags.3",
FT_BOOLEAN, 16, NULL, 0x8, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0008, NULL, HFILL
}
},
{ &hf_awdl_datastate_flags_4,
{ "UMI", "awdl.datastate.flags.4",
FT_BOOLEAN, 16, NULL, 0x10, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0010, NULL, HFILL
}
},
{ &hf_awdl_datastate_flags_5,
{ "Bit 5", "awdl.datastate.flags.5",
FT_BOOLEAN, 16, NULL, 0x20, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0020, NULL, HFILL
}
},
{ &hf_awdl_datastate_flags_6,
{ "Is AirPlay (?)", "awdl.datastate.flags.6",
FT_BOOLEAN, 16, NULL, 0x40, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0040, NULL, HFILL
}
},
{ &hf_awdl_datastate_flags_7,
{ "Bit 6", "awdl.datastate.flags.7",
FT_BOOLEAN, 16, NULL, 0x80, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0080, NULL, HFILL
}
},
{ &hf_awdl_datastate_flags_8,
@ -2237,122 +2237,122 @@ void proto_register_awdl(void)
*/
{ &hf_awdl_serviceparams_bitmask_0,
{ "0", "awdl.serviceparams.bitmask.0",
FT_BOOLEAN, 32, NULL, 0x1, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00000001, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_1,
{ "1", "awdl.serviceparams.bitmask.1",
FT_BOOLEAN, 32, NULL, 0x2, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00000002, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_2,
{ "2", "awdl.serviceparams.bitmask.2",
FT_BOOLEAN, 32, NULL, 0x4, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00000004, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_3,
{ "3", "awdl.serviceparams.bitmask.3",
FT_BOOLEAN, 32, NULL, 0x8, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00000008, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_4,
{ "4", "awdl.serviceparams.bitmask.4",
FT_BOOLEAN, 32, NULL, 0x10, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00000010, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_5,
{ "5", "awdl.serviceparams.bitmask.5",
FT_BOOLEAN, 32, NULL, 0x20, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00000020, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_6,
{ "6", "awdl.serviceparams.bitmask.6",
FT_BOOLEAN, 32, NULL, 0x40, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00000040, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_7,
{ "7", "awdl.serviceparams.bitmask.7",
FT_BOOLEAN, 32, NULL, 0x80, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00000080, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_8,
{ "8", "awdl.serviceparams.bitmask.8",
FT_BOOLEAN, 32, NULL, 0x0100, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00000100, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_9,
{ "9", "awdl.serviceparams.bitmask.9",
FT_BOOLEAN, 32, NULL, 0x0200, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00000200, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_10,
{ "10", "awdl.serviceparams.bitmask.10",
FT_BOOLEAN, 32, NULL, 0x0400, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00000400, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_11,
{ "11", "awdl.serviceparams.bitmask.11",
FT_BOOLEAN, 32, NULL, 0x0800, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00000800, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_12,
{ "12", "awdl.serviceparams.bitmask.12",
FT_BOOLEAN, 32, NULL, 0x1000, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00001000, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_13,
{ "13", "awdl.serviceparams.bitmask.13",
FT_BOOLEAN, 32, NULL, 0x2000, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00002000, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_14,
{ "14", "awdl.serviceparams.bitmask.14",
FT_BOOLEAN, 32, NULL, 0x4000, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00004000, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_15,
{ "15", "awdl.serviceparams.bitmask.15",
FT_BOOLEAN, 32, NULL, 0x8000, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00008000, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_16,
{ "16", "awdl.serviceparams.bitmask.16",
FT_BOOLEAN, 32, NULL, 0x010000, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00010000, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_17,
{ "17", "awdl.serviceparams.bitmask.17",
FT_BOOLEAN, 32, NULL, 0x020000, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00020000, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_18,
{ "18", "awdl.serviceparams.bitmask.18",
FT_BOOLEAN, 32, NULL, 0x040000, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00040000, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_19,
{ "19", "awdl.serviceparams.bitmask.19",
FT_BOOLEAN, 32, NULL, 0x080000, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00080000, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_20,
{ "20", "awdl.serviceparams.bitmask.20",
FT_BOOLEAN, 32, NULL, 0x100000, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00100000, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_21,
{ "21", "awdl.serviceparams.bitmask.21",
FT_BOOLEAN, 32, NULL, 0x200000, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00200000, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_22,
{ "22", "awdl.serviceparams.bitmask.22",
FT_BOOLEAN, 32, NULL, 0x400000, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00400000, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_23,
{ "23", "awdl.serviceparams.bitmask.23",
FT_BOOLEAN, 32, NULL, 0x800000, NULL, HFILL
FT_BOOLEAN, 32, NULL, 0x00800000, NULL, HFILL
}
},
{ &hf_awdl_serviceparams_bitmask_24,

2
epan/dissectors/packet-btamp.c
View File

@ -584,7 +584,7 @@ proto_register_btamp(void)
},
{ &hf_btamp_pal_caps_guaranteed,
{ "Guaranteed Service type", "btamp.guaranteed_type",
FT_BOOLEAN, 16, NULL, 0x01,
FT_BOOLEAN, 16, NULL, 0x0001,
NULL, HFILL }
},
{ &hf_btamp_total_bw,

112
epan/dissectors/packet-btatt.c
View File

@ -13098,32 +13098,32 @@ proto_register_btatt(void)
},
{&hf_btatt_blood_pressure_feature_multiple_bond,
{"Multiple Bond", "btatt.blood_pressure.feature.multiple_bond",
FT_BOOLEAN, 16, NULL, 0x20,
FT_BOOLEAN, 16, NULL, 0x0020,
NULL, HFILL}
},
{&hf_btatt_blood_pressure_feature_measurement_position_detection,
{"Measurement Position Detection", "btatt.blood_pressure.feature.measurement_position_detection",
FT_BOOLEAN, 16, NULL, 0x10,
FT_BOOLEAN, 16, NULL, 0x0010,
NULL, HFILL}
},
{&hf_btatt_blood_pressure_feature_puls_rate_range,
{"Puls Rate Range", "btatt.blood_pressure.feature.puls_rate_range",
FT_BOOLEAN, 16, NULL, 0x08,
FT_BOOLEAN, 16, NULL, 0x0008,
NULL, HFILL}
},
{&hf_btatt_blood_pressure_feature_irregular_pulse_detection,
{"Irregular Pulse Detection", "btatt.blood_pressure.feature.irregular_pulse_detection",
FT_BOOLEAN, 16, NULL, 0x04,
FT_BOOLEAN, 16, NULL, 0x0004,
NULL, HFILL}
},
{&hf_btatt_blood_pressure_feature_cuff_fit_detection,
{"Cuff Fit Detection", "btatt.blood_pressure.feature.cuff_fit_detection",
FT_BOOLEAN, 16, NULL, 0x02,
FT_BOOLEAN, 16, NULL, 0x0002,
NULL, HFILL}
},
{&hf_btatt_blood_pressure_feature_body_movement_detection,
{"Body Movement Detection", "btatt.blood_pressure.feature.body_movement_detection",
FT_BOOLEAN, 16, NULL, 0x01,
FT_BOOLEAN, 16, NULL, 0x0001,
NULL, HFILL}
},
{&hf_btatt_hogp_hid_control_point_command,
@ -15130,52 +15130,52 @@ proto_register_btatt(void)
},
{&hf_btatt_cycling_power_control_point_content_mask_reserved,
{"Reserved", "btatt.cycling_power_control_point.content_mask.reserved",
FT_UINT16, BASE_HEX, NULL, 0xFE0,
FT_UINT16, BASE_HEX, NULL, 0x0FE0,
NULL, HFILL}
},
{&hf_btatt_cycling_power_control_point_content_mask_accumulated_energy,
{"Accumulated Energy", "btatt.cycling_power_control_point.content_mask.accumulated_energy",
FT_BOOLEAN, 16, TFS(&control_point_mask_value_tfs), 0x100,
FT_BOOLEAN, 16, TFS(&control_point_mask_value_tfs), 0x0100,
NULL, HFILL}
},
{&hf_btatt_cycling_power_control_point_content_mask_bottom_dead_spot_angle,
{"Bottom Dead Spot Angle", "btatt.cycling_power_control_point.content_mask.bottom_dead_spot_angle",
FT_BOOLEAN, 16, TFS(&control_point_mask_value_tfs), 0x080,
FT_BOOLEAN, 16, TFS(&control_point_mask_value_tfs), 0x0080,
NULL, HFILL}
},
{&hf_btatt_cycling_power_control_point_content_mask_top_dead_spot_angle,
{"Top Dead Spot Angle", "btatt.cycling_power_control_point.content_mask.top_dead_spot_angle",
FT_BOOLEAN, 16, TFS(&control_point_mask_value_tfs), 0x040,
FT_BOOLEAN, 16, TFS(&control_point_mask_value_tfs), 0x0040,
NULL, HFILL}
},
{&hf_btatt_cycling_power_control_point_content_mask_extreme_angles,
{"Extreme Angles", "btatt.cycling_power_control_point.content_mask.extreme_angles",
FT_BOOLEAN, 16, TFS(&control_point_mask_value_tfs), 0x020,
FT_BOOLEAN, 16, TFS(&control_point_mask_value_tfs), 0x0020,
NULL, HFILL}
},
{&hf_btatt_cycling_power_control_point_content_mask_extreme_magnitudes,
{"Extreme Magnitudes", "btatt.cycling_power_control_point.content_mask.extreme_magnitudes",
FT_BOOLEAN, 16, TFS(&control_point_mask_value_tfs), 0x010,
FT_BOOLEAN, 16, TFS(&control_point_mask_value_tfs), 0x0010,
NULL, HFILL}
},
{&hf_btatt_cycling_power_control_point_content_mask_crank_revolution_data,
{"Crank Revolution Data", "btatt.cycling_power_control_point.content_mask.crank_revolution_data",
FT_BOOLEAN, 16, TFS(&control_point_mask_value_tfs), 0x008,
FT_BOOLEAN, 16, TFS(&control_point_mask_value_tfs), 0x0008,
NULL, HFILL}
},
{&hf_btatt_cycling_power_control_point_content_mask_wheel_revolution_data,
{"Wheel Revolution Data", "btatt.cycling_power_control_point.content_mask.wheel_revolution_data",
FT_BOOLEAN, 16, TFS(&control_point_mask_value_tfs), 0x004,
FT_BOOLEAN, 16, TFS(&control_point_mask_value_tfs), 0x0004,
NULL, HFILL}
},
{&hf_btatt_cycling_power_control_point_content_mask_accumulated_torque,
{"Accumulated Torque", "btatt.cycling_power_control_point.content_mask.accumulated_torque",
FT_BOOLEAN, 16, TFS(&control_point_mask_value_tfs), 0x002,
FT_BOOLEAN, 16, TFS(&control_point_mask_value_tfs), 0x0002,
NULL, HFILL}
},
{&hf_btatt_cycling_power_control_point_content_mask_pedal_power_balance,
{"Pedal Power Balance", "btatt.cycling_power_control_point.content_mask.pedal_power_balance",
FT_BOOLEAN, 16, TFS(&control_point_mask_value_tfs), 0x001,
FT_BOOLEAN, 16, TFS(&control_point_mask_value_tfs), 0x0001,
NULL, HFILL}
},
{&hf_btatt_cycling_power_control_point_request_opcode,
@ -17813,102 +17813,102 @@ proto_register_btgatt(void)
},
{&hf_gatt_microbit_ad_pin0,
{"Pin 0", "btgatt.microbit.pin_ad_config.pin0",
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x000001,
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x00001,
NULL, HFILL}
},
{&hf_gatt_microbit_ad_pin1,
{"Pin 1", "btgatt.microbit.pin_ad_config.pin1",
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x000002,
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x00002,
NULL, HFILL}
},
{&hf_gatt_microbit_ad_pin2,
{"Pin 2", "btgatt.microbit.pin_ad_config.pin2",
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x000004,
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x00004,
NULL, HFILL}
},
{&hf_gatt_microbit_ad_pin3,
{"Pin 3", "btgatt.microbit.pin_ad_config.pin3",
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x000008,
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x00008,
NULL, HFILL}
},
{&hf_gatt_microbit_ad_pin4,
{"Pin 4", "btgatt.microbit.pin_ad_config.pin4",
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x000010,
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x00010,
NULL, HFILL}
},
{&hf_gatt_microbit_ad_pin5,
{"Pin 5", "btgatt.microbit.pin_ad_config.pin5",
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x000020,
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x00020,
NULL, HFILL}
},
{&hf_gatt_microbit_ad_pin6,
{"Pin 6", "btgatt.microbit.pin_ad_config.pin6",
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x000040,
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x00040,
NULL, HFILL}
},
{&hf_gatt_microbit_ad_pin7,
{"Pin 7", "btgatt.microbit.pin_ad_config.pin7",
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x000080,
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x00080,
NULL, HFILL}
},
{&hf_gatt_microbit_ad_pin8,
{"Pin 8", "btgatt.microbit.pin_ad_config.pin8",
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x000100,
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x00100,
NULL, HFILL}
},
{&hf_gatt_microbit_ad_pin9,
{"Pin 9", "btgatt.microbit.pin_ad_config.pin9",
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x000200,
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x00200,
NULL, HFILL}
},
{&hf_gatt_microbit_ad_pin10,
{"Pin 10", "btgatt.microbit.pin_ad_config.pin10",
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x000400,
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x00400,
NULL, HFILL}
},
{&hf_gatt_microbit_ad_pin11,
{"Pin 11", "btgatt.microbit.pin_ad_config.pin11",
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x000800,
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x00800,
NULL, HFILL}
},
{&hf_gatt_microbit_ad_pin12,
{"Pin 12", "btgatt.microbit.pin_ad_config.pin12",
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x001000,
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x01000,
NULL, HFILL}
},
{&hf_gatt_microbit_ad_pin13,
{"Pin 13", "btgatt.microbit.pin_ad_config.pin13",
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x002000,
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x02000,
NULL, HFILL}
},
{&hf_gatt_microbit_ad_pin14,
{"Pin 14", "btgatt.microbit.pin_ad_config.pin14",
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x004000,
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x04000,
NULL, HFILL}
},
{&hf_gatt_microbit_ad_pin15,
{"Pin 15", "btgatt.microbit.pin_ad_config.pin15",
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x008000,
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x08000,
NULL, HFILL}
},
{&hf_gatt_microbit_ad_pin16,
{"Pin 16", "btgatt.microbit.pin_ad_config.pin16",
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x010000,
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x10000,
NULL, HFILL}
},
{&hf_gatt_microbit_ad_pin17,
{"Pin 17", "btgatt.microbit.pin_ad_config.pin17",
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x020000,
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x20000,
NULL, HFILL}
},
{&hf_gatt_microbit_ad_pin18,
{"Pin 18", "btgatt.microbit.pin_ad_config.pin18",
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x040000,
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x40000,
NULL, HFILL}
},
{&hf_gatt_microbit_ad_pin19,
{"Pin 19", "btgatt.microbit.pin_ad_config.pin19",
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x080000,
FT_BOOLEAN, 20, TFS(&microbit_ad_tfs), 0x80000,
NULL, HFILL}
},
{&hf_gatt_microbit_pin_io_config,
@ -17918,102 +17918,102 @@ proto_register_btgatt(void)
},
{&hf_gatt_microbit_io_pin0,
{"Pin 0", "btgatt.microbit.pin_io_config.pin0",
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x000001,
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x00001,
NULL, HFILL}
},
{&hf_gatt_microbit_io_pin1,
{"Pin 1", "btgatt.microbit.pin_io_config.pin1",
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x000002,
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x00002,
NULL, HFILL}
},
{&hf_gatt_microbit_io_pin2,
{"Pin 2", "btgatt.microbit.pin_io_config.pin2",
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x000004,
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x00004,
NULL, HFILL}
},
{&hf_gatt_microbit_io_pin3,
{"Pin 3", "btgatt.microbit.pin_io_config.pin3",
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x000008,
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x00008,
NULL, HFILL}
},
{&hf_gatt_microbit_io_pin4,
{"Pin 4", "btgatt.microbit.pin_io_config.pin4",
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x000010,
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x00010,
NULL, HFILL}
},
{&hf_gatt_microbit_io_pin5,
{"Pin 5", "btgatt.microbit.pin_io_config.pin5",
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x000020,
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x00020,
NULL, HFILL}
},
{&hf_gatt_microbit_io_pin6,
{"Pin 6", "btgatt.microbit.pin_io_config.pin6",
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x000040,
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x00040,
NULL, HFILL}
},
{&hf_gatt_microbit_io_pin7,
{"Pin 7", "btgatt.microbit.pin_io_config.pin7",
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x000080,
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x00080,
NULL, HFILL}
},
{&hf_gatt_microbit_io_pin8,
{"Pin 8", "btgatt.microbit.pin_io_config.pin8",
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x000100,
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x00100,
NULL, HFILL}
},
{&hf_gatt_microbit_io_pin9,
{"Pin 9", "btgatt.microbit.pin_io_config.pin9",
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x000200,
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x00200,
NULL, HFILL}
},
{&hf_gatt_microbit_io_pin10,
{"Pin 10", "btgatt.microbit.pin_io_config.pin10",
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x000400,
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x00400,
NULL, HFILL}
},
{&hf_gatt_microbit_io_pin11,
{"Pin 11", "btgatt.microbit.pin_io_config.pin11",
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x000800,
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x00800,
NULL, HFILL}
},
{&hf_gatt_microbit_io_pin12,
{"Pin 12", "btgatt.microbit.pin_io_config.pin12",
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x001000,
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x01000,
NULL, HFILL}
},
{&hf_gatt_microbit_io_pin13,
{"Pin 13", "btgatt.microbit.pin_io_config.pin13",
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x002000,
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x02000,
NULL, HFILL}
},
{&hf_gatt_microbit_io_pin14,
{"Pin 14", "btgatt.microbit.pin_io_config.pin14",
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x004000,
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x04000,
NULL, HFILL}
},
{&hf_gatt_microbit_io_pin15,
{"Pin 15", "btgatt.microbit.pin_io_config.pin15",
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x008000,
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x08000,
NULL, HFILL}
},
{&hf_gatt_microbit_io_pin16,
{"Pin 16", "btgatt.microbit.pin_io_config.pin16",
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x010000,
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x10000,
NULL, HFILL}
},
{&hf_gatt_microbit_io_pin17,
{"Pin 17", "btgatt.microbit.pin_io_config.pin17",
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x020000,
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x20000,
NULL, HFILL}
},
{&hf_gatt_microbit_io_pin18,
{"Pin 18", "btgatt.microbit.pin_io_config.pin18",
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x040000,
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x40000,
NULL, HFILL}
},
{&hf_gatt_microbit_io_pin19,
{"Pin 19", "btgatt.microbit.pin_io_config.pin19",
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x080000,
FT_BOOLEAN, 20, TFS(&microbit_io_tfs), 0x80000,
NULL, HFILL}
},
{&hf_gatt_microbit_pwm_control,

22
epan/dissectors/packet-cdp.c
View File

@ -1349,47 +1349,47 @@ proto_register_cdp(void)
{ &hf_cdp_capabilities_router,
{"Router", "cdp.capabilities.router", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), 0x01, NULL, HFILL }},
TFS(&tfs_yes_no), 0x00000001, NULL, HFILL }},
{ &hf_cdp_capabilities_trans_bridge,
{"Transparent Bridge", "cdp.capabilities.trans_bridge", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), 0x02, NULL, HFILL }},
TFS(&tfs_yes_no), 0x00000002, NULL, HFILL }},
{ &hf_cdp_capabilities_src_bridge,
{"Source Route Bridge", "cdp.capabilities.src_bridge", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), 0x04, NULL, HFILL }},
TFS(&tfs_yes_no), 0x00000004, NULL, HFILL }},
{ &hf_cdp_capabilities_switch,
{"Switch", "cdp.capabilities.switch", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), 0x08, NULL, HFILL }},
TFS(&tfs_yes_no), 0x00000008, NULL, HFILL }},
{ &hf_cdp_capabilities_host,
{"Host", "cdp.capabilities.host", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), 0x10, NULL, HFILL }},
TFS(&tfs_yes_no), 0x00000010, NULL, HFILL }},
{ &hf_cdp_capabilities_igmp_capable,
{"IGMP capable", "cdp.capabilities.igmp_capable", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), 0x20, NULL, HFILL }},
TFS(&tfs_yes_no), 0x00000020, NULL, HFILL }},
{ &hf_cdp_capabilities_repeater,
{"Repeater", "cdp.capabilities.repeater", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), 0x40, NULL, HFILL }},
TFS(&tfs_yes_no), 0x00000040, NULL, HFILL }},
{ &hf_cdp_capabilities_voip_phone,
{"VoIP Phone", "cdp.capabilities.voip_phone", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), 0x80, NULL, HFILL }},
TFS(&tfs_yes_no), 0x00000080, NULL, HFILL }},
{ &hf_cdp_capabilities_remote,
{"Remotely Managed Device", "cdp.capabilities.remote", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), 0x0100, NULL, HFILL }},
TFS(&tfs_yes_no), 0x00000100, NULL, HFILL }},
{ &hf_cdp_capabilities_cvta,
{"CVTA/STP Dispute Resolution/Cisco VT Camera", "cdp.capabilities.cvta", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), 0x0200, NULL, HFILL }},
TFS(&tfs_yes_no), 0x00000200, NULL, HFILL }},
{ &hf_cdp_capabilities_mac_relay,
{"Two Port Mac Relay", "cdp.capabilities.mac_relay", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), 0x0400, NULL, HFILL }},
TFS(&tfs_yes_no), 0x00000400, NULL, HFILL }},
{ &hf_cdp_spare_poe_tlv,
{ "Spare Pair PoE", "cdp.spare_poe_tlv", FT_UINT8, BASE_HEX,

56
epan/dissectors/packet-couchbase.c
View File

@ -1515,6 +1515,7 @@ dissect_client_extras(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
NULL
};
/* TODO: extra_flags fields are 16-bits wide, whereas flags is 4 bytes? */
tf = proto_tree_add_bitmask(extras_tree, tvb, offset, hf_extras_flags, ett_extras_flags, extra_flags, ENC_BIG_ENDIAN);
flags = tvb_get_ntohl(tvb, offset);
@ -1606,7 +1607,7 @@ dissect_client_extras(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
};
proto_tree_add_bitmask(extras_tree, tvb, offset, hf_extras_flags, ett_extras_flags, extra_flags, ENC_BIG_ENDIAN);
*/
*/
proto_tree_add_item(extras_tree, hf_extras_flags, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
proto_tree_add_item(extras_tree, hf_extras_reserved, tvb, offset, 4, ENC_BIG_ENDIAN);
@ -1994,6 +1995,7 @@ dissect_client_extras(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
// Options field (4 bytes)
if (extlen == 28 || extlen == 30) {
/* TODO: these fields are all 16 bits wide, but field is 32 bits? */
proto_tree_add_bitmask(
extras_tree,
tvb,
@ -3812,13 +3814,13 @@ proto_register_couchbase(void)
{ &hf_extras, { "Extras", "couchbase.extras", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } },
{ &hf_extras_flags, { "Flags", "couchbase.extras.flags", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
{ &hf_extras_flags_backfill, { "Backfill Age", "couchbase.extras.flags.backfill", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x01, NULL, HFILL } },
{ &hf_extras_flags_dump, { "Dump", "couchbase.extras.flags.dump", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x02, NULL, HFILL } },
{ &hf_extras_flags_list_vbuckets, { "List VBuckets", "couchbase.extras.flags.list_vbuckets", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x04, NULL, HFILL } },
{ &hf_extras_flags_takeover_vbuckets, { "Takeover VBuckets", "couchbase.extras.flags.takeover_vbuckets", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x08, NULL, HFILL } },
{ &hf_extras_flags_support_ack, { "Support ACK", "couchbase.extras.flags.support_ack", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x10, NULL, HFILL } },
{ &hf_extras_flags_request_keys_only, { "Request Keys Only", "couchbase.extras.flags.request_keys_only", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x20, NULL, HFILL } },
{ &hf_extras_flags_checkpoint, { "Checkpoint", "couchbase.extras.flags.checkpoint", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x40, NULL, HFILL } },
{ &hf_extras_flags_backfill, { "Backfill Age", "couchbase.extras.flags.backfill", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0001, NULL, HFILL } },
{ &hf_extras_flags_dump, { "Dump", "couchbase.extras.flags.dump", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0002, NULL, HFILL } },
{ &hf_extras_flags_list_vbuckets, { "List VBuckets", "couchbase.extras.flags.list_vbuckets", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0004, NULL, HFILL } },
{ &hf_extras_flags_takeover_vbuckets, { "Takeover VBuckets", "couchbase.extras.flags.takeover_vbuckets", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0008, NULL, HFILL } },
{ &hf_extras_flags_support_ack, { "Support ACK", "couchbase.extras.flags.support_ack", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0010, NULL, HFILL } },
{ &hf_extras_flags_request_keys_only, { "Request Keys Only", "couchbase.extras.flags.request_keys_only", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0020, NULL, HFILL } },
{ &hf_extras_flags_checkpoint, { "Checkpoint", "couchbase.extras.flags.checkpoint", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0040, NULL, HFILL } },
/* Sub-document */
{ &hf_subdoc_flags, { "Subdoc flags", "couchbase.extras.subdoc.flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL} },
@ -3836,20 +3838,20 @@ proto_register_couchbase(void)
{ &hf_extras_pathlen, { "Path Length", "couchbase.extras.pathlen", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
/* DCP flags */
{ &hf_extras_flags_dcp_connection_type, {"Connection Type", "couchbase.extras.flags.dcp_connection_type", FT_UINT32, BASE_HEX, VALS(dcp_connection_type_vals), 0x03, NULL, HFILL } },
{ &hf_extras_flags_dcp_add_stream_takeover, {"Take Over", "couchbase.extras.flags.dcp_add_stream_takeover", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x01, NULL, HFILL } },
{ &hf_extras_flags_dcp_add_stream_diskonly, {"Disk Only", "couchbase.extras.flags.dcp_add_stream_diskonly", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x02, NULL, HFILL } },
{ &hf_extras_flags_dcp_add_stream_latest, {"Latest", "couchbase.extras.flags.dcp_add_stream_latest", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x04, NULL, HFILL } },
{ &hf_extras_flags_dcp_snapshot_marker_memory, {"Memory", "couchbase.extras.flags.dcp_snapshot_marker_memory", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x01, NULL, HFILL } },
{ &hf_extras_flags_dcp_snapshot_marker_disk, {"Disk", "couchbase.extras.flags.dcp_snapshot_marker_disk", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x02, NULL, HFILL } },
{ &hf_extras_flags_dcp_snapshot_marker_chk, {"Chk", "couchbase.extras.flags.dcp_snapshot_marker_chk", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x04, NULL, HFILL } },
{ &hf_extras_flags_dcp_snapshot_marker_ack, {"Ack", "couchbase.extras.flags.dcp_snapshot_marker_ack", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x08, NULL, HFILL } },
{ &hf_extras_flags_dcp_include_xattrs, {"Include XATTRs", "couchbase.extras.flags.dcp_include_xattrs", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x04, "Indicates the server should include documents XATTRs", HFILL} },
{ &hf_extras_flags_dcp_no_value, {"No Value", "couchbase.extras.flags.dcp_no_value", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x08, "Indicates the server should strip off values", HFILL} },
{ &hf_extras_flags_dcp_collections, {"Enable Collections", "couchbase.extras.flags.dcp_collections", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x10, "Indicates the server should stream collections", HFILL} },
{ &hf_extras_flags_dcp_include_delete_times, {"Include Delete Times", "couchbase.extras.flags.dcp_include_delete_times", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x20, "Indicates the server should include delete timestamps", HFILL} },
{ &hf_extras_flags_dcp_oso_snapshot_begin, {"OSO Begin", "couchbase.extras.flags.dcp_oso_snapshot_begin", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x1, "The start of an OSO snapshot", HFILL} },
{ &hf_extras_flags_dcp_oso_snapshot_end, {"OSO End", "couchbase.extras.flags.dcp_oso_snapshot_end", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x2, "The end of an OSO snapshot", HFILL} },
{ &hf_extras_flags_dcp_connection_type, {"Connection Type", "couchbase.extras.flags.dcp_connection_type", FT_UINT32, BASE_HEX, VALS(dcp_connection_type_vals), 0x00000003, NULL, HFILL } },
{ &hf_extras_flags_dcp_add_stream_takeover, {"Take Over", "couchbase.extras.flags.dcp_add_stream_takeover", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0001, NULL, HFILL } },
{ &hf_extras_flags_dcp_add_stream_diskonly, {"Disk Only", "couchbase.extras.flags.dcp_add_stream_diskonly", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0002, NULL, HFILL } },
{ &hf_extras_flags_dcp_add_stream_latest, {"Latest", "couchbase.extras.flags.dcp_add_stream_latest", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0004, NULL, HFILL } },
{ &hf_extras_flags_dcp_snapshot_marker_memory, {"Memory", "couchbase.extras.flags.dcp_snapshot_marker_memory", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0001, NULL, HFILL } },
{ &hf_extras_flags_dcp_snapshot_marker_disk, {"Disk", "couchbase.extras.flags.dcp_snapshot_marker_disk", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0002, NULL, HFILL } },
{ &hf_extras_flags_dcp_snapshot_marker_chk, {"Chk", "couchbase.extras.flags.dcp_snapshot_marker_chk", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0004, NULL, HFILL } },
{ &hf_extras_flags_dcp_snapshot_marker_ack, {"Ack", "couchbase.extras.flags.dcp_snapshot_marker_ack", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0008, NULL, HFILL } },
{ &hf_extras_flags_dcp_include_xattrs, {"Include XATTRs", "couchbase.extras.flags.dcp_include_xattrs", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0004, "Indicates the server should include documents XATTRs", HFILL} },
{ &hf_extras_flags_dcp_no_value, {"No Value", "couchbase.extras.flags.dcp_no_value", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0008, "Indicates the server should strip off values", HFILL} },
{ &hf_extras_flags_dcp_collections, {"Enable Collections", "couchbase.extras.flags.dcp_collections", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0010, "Indicates the server should stream collections", HFILL} },
{ &hf_extras_flags_dcp_include_delete_times, {"Include Delete Times", "couchbase.extras.flags.dcp_include_delete_times", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0020, "Indicates the server should include delete timestamps", HFILL} },
{ &hf_extras_flags_dcp_oso_snapshot_begin, {"OSO Begin", "couchbase.extras.flags.dcp_oso_snapshot_begin", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0001, "The start of an OSO snapshot", HFILL} },
{ &hf_extras_flags_dcp_oso_snapshot_end, {"OSO End", "couchbase.extras.flags.dcp_oso_snapshot_end", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0002, "The end of an OSO snapshot", HFILL} },
{ &hf_extras_seqno, { "Sequence number", "couchbase.extras.seqno", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_extras_mutation_seqno, { "Mutation Sequence Number", "couchbase.extras.mutation_seqno", FT_UINT64, BASE_DEC, NULL, 0x0, NULL, HFILL } },
@ -3926,11 +3928,11 @@ proto_register_couchbase(void)
{ &hf_meta_revseqno, {"RevSeqno", "couchbase.extras.revseqno", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL} },
{ &hf_meta_cas, {"CAS", "couchbase.extras.cas", FT_UINT64, BASE_HEX, NULL, 0x0, NULL, HFILL} },
{ &hf_meta_options, {"Options", "couchbase.extras.options", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL} },
{ &hf_force_meta, {"FORCE_WITH_META_OP", "couchbase.extras.options.force_with_meta_op", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x01, NULL, HFILL} },
{ &hf_force_accept, {"FORCE_ACCEPT_WITH_META_OPS", "couchbase.extras.options.force_accept_with_meta_ops", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x02, NULL, HFILL} },
{ &hf_regenerate_cas, {"REGENERATE_CAS", "couchbase.extras.option.regenerate_cas", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x04, NULL, HFILL} },
{ &hf_skip_conflict, {"SKIP_CONFLICT_RESOLUTION", "couchbase.extras.options.skip_conflict_resolution", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x08, NULL, HFILL} },
{ &hf_is_expiration, {"IS_EXPIRATION", "couchbase.extras.options.is_expiration", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x10, NULL, HFILL} },
{ &hf_force_meta, {"FORCE_WITH_META_OP", "couchbase.extras.options.force_with_meta_op", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0001, NULL, HFILL} },
{ &hf_force_accept, {"FORCE_ACCEPT_WITH_META_OPS", "couchbase.extras.options.force_accept_with_meta_ops", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0002, NULL, HFILL} },
{ &hf_regenerate_cas, {"REGENERATE_CAS", "couchbase.extras.option.regenerate_cas", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0004, NULL, HFILL} },
{ &hf_skip_conflict, {"SKIP_CONFLICT_RESOLUTION", "couchbase.extras.options.skip_conflict_resolution", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0008, NULL, HFILL} },
{ &hf_is_expiration, {"IS_EXPIRATION", "couchbase.extras.options.is_expiration", FT_BOOLEAN, 16, TFS(&tfs_set_notset), 0x0010, NULL, HFILL} },
{ &hf_metalen, {"Meta Length", "couchbase.extras.meta_length", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL} },
{ &hf_meta_reqextmeta, {"ReqExtMeta", "couchbase.extras.reqextmeta", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL} },
{ &hf_meta_deleted, {"Deleted", "couchbase.extras.deleted", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL} },

70
epan/dissectors/packet-dhcp.c
View File

@ -7527,17 +7527,17 @@ proto_register_dhcp(void)
{ &hf_dhcp_pkt_mdc_supp_flow_secure,
{ "Secure Flow (Full Secure Provisioning Flow)", "dhcp.vendor.pktc.mdc.supp_flow.secure",
FT_BOOLEAN, 16, TFS(&tfs_supported_not_supported), 0x01,
FT_BOOLEAN, 16, TFS(&tfs_supported_not_supported), 0x0001,
NULL, HFILL }},
{ &hf_dhcp_pkt_mdc_supp_flow_hybrid,
{ "Hybrid Flow", "dhcp.vendor.pktc.mdc.supp_flow.hybrid",
FT_BOOLEAN, 16, TFS(&tfs_supported_not_supported), 0x02,
FT_BOOLEAN, 16, TFS(&tfs_supported_not_supported), 0x0002,
NULL, HFILL }},
{ &hf_dhcp_pkt_mdc_supp_flow_basic,
{ "Basic Flow", "dhcp.vendor.pktc.mdc.supp_flow.basic",
FT_BOOLEAN, 16, TFS(&tfs_supported_not_supported), 0x04,
FT_BOOLEAN, 16, TFS(&tfs_supported_not_supported), 0x0004,
NULL, HFILL }},
{ &hf_dhcp_pkt_mdc_mib_cl_mta,
@ -7642,149 +7642,151 @@ proto_register_dhcp(void)
{ &hf_dhcp_docsis_cm_cap_ranging_hold_off_cm,
{ "CM", "dhcp.docsis_cm_cap.ranging_hold_off.cm",
FT_BOOLEAN, 16, TFS(&tfs_supported_not_supported), 0x01,
FT_BOOLEAN, 16, TFS(&tfs_supported_not_supported), 0x0001,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_ranging_hold_off_eps,
{ "ePS or eRouter", "dhcp.docsis_cm_cap.ranging_hold_off.eps",
FT_BOOLEAN, 16, TFS(&tfs_supported_not_supported), 0x02,
FT_BOOLEAN, 16, TFS(&tfs_supported_not_supported), 0x0002,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_ranging_hold_off_emta,
{ "EMTA or EDVA", "dhcp.docsis_cm_cap.ranging_hold_off.emta",
FT_BOOLEAN, 16, TFS(&tfs_supported_not_supported), 0x04,
FT_BOOLEAN, 16, TFS(&tfs_supported_not_supported), 0x0004,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_ranging_hold_off_dsg,
{ "DSG/eSTB", "dhcp.docsis_cm_cap.ranging_hold_off.dsg",
FT_BOOLEAN, 16, TFS(&tfs_supported_not_supported), 0x08,
FT_BOOLEAN, 16, TFS(&tfs_supported_not_supported), 0x0008,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_stpid,
{ "[IEEE 802.1ad] S-TPID", "dhcp.docsis_cm_cap.mpls.stpid",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x01,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00000001,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_svid,
{ "[IEEE 802.1ad] S-VID", "dhcp.docsis_cm_cap.mpls.svid",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x02,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00000002,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_spcp,
{ "[IEEE 802.1ad] S-PCP", "dhcp.docsis_cm_cap.mpls.spcp",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x04,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00000004,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_sdei,
{ "[IEEE 802.1ad] S-DEI", "dhcp.docsis_cm_cap.mpls.sdei",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x08,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00000008,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_ctpid,
{ "[IEEE 802.1ad] C-TPID", "dhcp.docsis_cm_cap.mpls.ctpid",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x10,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00000010,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_cvid,
{ "[IEEE 802.1ad] C-VID", "dhcp.docsis_cm_cap.mpls.cvid",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x20,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00000020,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_cpcp,
{ "[IEEE 802.1ad] C-PCP", "dhcp.docsis_cm_cap.mpls.cpcp",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x40,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00000040,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_ccfi,
{ "[IEEE 802.1ad] C-CFI", "dhcp.docsis_cm_cap.mpls.ccfi",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x80,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00000080,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_stci,
{ "[IEEE 802.1ad] S-TCI", "dhcp.docsis_cm_cap.mpls.stci",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x100,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00000100,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_ctci,
{ "[IEEE 802.1ad] C-TCI", "dhcp.docsis_cm_cap.mpls.ctci",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x200,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00000200,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_itpid,
{ "[IEEE 802.1ad] I-TPID", "dhcp.docsis_cm_cap.mpls.itpid",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x400,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00000400,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_isid,
{ "[IEEE 802.1ad] I-SID", "dhcp.docsis_cm_cap.mpls.isid",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x800,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00000800,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_itci,
{ "[IEEE 802.1ad] I-TCI", "dhcp.docsis_cm_cap.mpls.itci",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x1000,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00001000,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_ipcp,
{ "[IEEE 802.1ad] I-PCP", "dhcp.docsis_cm_cap.mpls.ipcp",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x2000,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00002000,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_idei,
{ "[IEEE 802.1ad] I-DEI", "dhcp.docsis_cm_cap.mpls.idei",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x4000,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00004000,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_iuca,
{ "[IEEE 802.1ad] I-UCA", "dhcp.docsis_cm_cap.mpls.iuca",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x8000,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00008000,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_btpid,
{ "[IEEE 802.1ad] B-TPID", "dhcp.docsis_cm_cap.mpls.btpid",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x10000,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00010000,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_btci,
{ "[IEEE 802.1ad] B-TCI", "dhcp.docsis_cm_cap.mpls.btci",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x20000,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00020000,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_bpcp,
{ "[IEEE 802.1ad] B-PCP", "dhcp.docsis_cm_cap.mpls.bpcp",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x40000,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00040000,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_bdei,
{ "[IEEE 802.1ad] B-DEI", "dhcp.docsis_cm_cap.mpls.bdei",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x80000,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00080000,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_bvid,
{ "[IEEE 802.1ad] B-VID", "dhcp.docsis_cm_cap.mpls.bvid",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x100000,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00100000,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_bda,
{ "[IEEE 802.1ad] B-DA", "dhcp.docsis_cm_cap.mpls.bda",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x200000,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00200000,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_bsa,
{ "[IEEE 802.1ad] B-SA", "dhcp.docsis_cm_cap.mpls.bsa",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x200000,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00400000,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_tc,
{ "MPLS TC", "dhcp.docsis_cm_cap.mpls.tc",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x200000,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x00800000,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_mpls_label,
{ "MPLS Label", "dhcp.docsis_cm_cap.mpls.label",
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x200000,
FT_BOOLEAN, 32, TFS(&tfs_supported_not_supported), 0x01000000,
NULL, HFILL }},
{ &hf_dhcp_docsis_cm_cap_ussymrate_160,
{ "160 ksps symbol rate", "dhcp.docsis_cm_cap.ussymrate.160",
FT_BOOLEAN, 8, TFS(&tfs_supported_not_supported), 0x01,
@ -9939,12 +9941,12 @@ proto_register_dhcp(void)
{ &hf_dhcp_ccc_ietf_sec_tkt_pc_provision_server,
{ "Invalidate PacketCable Provisioning Server", "dhcp.ccc.ietf.sec_tkt.pc_provision_server",
FT_BOOLEAN, 16, TFS(&tfs_yes_no), 0x01,
FT_BOOLEAN, 16, TFS(&tfs_yes_no), 0x0001,
NULL, HFILL }},
{ &hf_dhcp_ccc_ietf_sec_tkt_all_pc_call_management,
{ "Invalidate All PacketCable Call Management Servers", "dhcp.ccc.ietf.sec_tkt.all_pc_call_management",
FT_BOOLEAN, 16, TFS(&tfs_yes_no), 0x02,
FT_BOOLEAN, 16, TFS(&tfs_yes_no), 0x0002,
NULL, HFILL }},
{ &hf_dhcp_option242_avaya,

12
epan/dissectors/packet-fcels.c
View File

@ -2426,22 +2426,22 @@ proto_register_fcels (void)
TFS(&tfs_fc_fcels_fcpflags_retry), 1 << 8, NULL, HFILL}},
{ &hf_fcels_fcpflags_ccomp,
{"Comp", "fcels.fcpflags.ccomp", FT_BOOLEAN, 32,
TFS(&tfs_fc_fcels_fcpflags_ccomp), 0x0080, NULL, HFILL}},
TFS(&tfs_fc_fcels_fcpflags_ccomp), 0x00000080, NULL, HFILL}},
{ &hf_fcels_fcpflags_datao,
{"Data Overlay", "fcels.fcpflags.datao", FT_BOOLEAN, 32,
TFS(&tfs_fc_fcels_fcpflags_datao), 0x0040, NULL, HFILL}},
TFS(&tfs_fc_fcels_fcpflags_datao), 0x00000040, NULL, HFILL}},
{ &hf_fcels_fcpflags_initiator,
{"Initiator", "fcels.fcpflags.initiator", FT_BOOLEAN, 32,
TFS(&tfs_fc_fcels_fcpflags_initiator), 0x0020, NULL, HFILL}},
TFS(&tfs_fc_fcels_fcpflags_initiator), 0x00000020, NULL, HFILL}},
{ &hf_fcels_fcpflags_target,
{"Target", "fcels.fcpflags.target", FT_BOOLEAN, 32,
TFS(&tfs_fc_fcels_fcpflags_target), 0x0010, NULL, HFILL}},
TFS(&tfs_fc_fcels_fcpflags_target), 0x00000010, NULL, HFILL}},
{ &hf_fcels_fcpflags_rdxr,
{"Rd Xfer_Rdy Dis", "fcels.fcpflags.rdxr", FT_BOOLEAN, 32,
TFS(&tfs_fc_fcels_fcpflags_rdxr), 0x0002, NULL, HFILL}},
TFS(&tfs_fc_fcels_fcpflags_rdxr), 0x00000002, NULL, HFILL}},
{ &hf_fcels_fcpflags_wrxr,
{"Wr Xfer_Rdy Dis", "fcels.fcpflags.wrxr", FT_BOOLEAN, 32,
TFS(&tfs_fc_fcels_fcpflags_wrxr), 0x0001, NULL, HFILL}},
TFS(&tfs_fc_fcels_fcpflags_wrxr), 0x00000001, NULL, HFILL}},
{ &hf_fcels_prliloflags,
{"PRLILO Flags", "fcels.prliloflags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL,
HFILL}},

6
epan/dissectors/packet-gtp.c
View File

@ -11362,17 +11362,17 @@ proto_register_gtp(void)
},
{ &hf_gtp_qos_arp_pci,
{"Pre-emption Capability (PCI)", "gtp.qos_arp_pci",
FT_BOOLEAN, 16, TFS(&tfs_disabled_enabled), 0x40,
FT_BOOLEAN, 16, TFS(&tfs_disabled_enabled), 0x0040,
NULL, HFILL}
},
{ &hf_gtp_qos_arp_pl,
{"Priority Level", "gtp.qos_arp_pl",
FT_UINT16, BASE_DEC, NULL, 0x3c,
FT_UINT16, BASE_DEC, NULL, 0x003c,
NULL, HFILL}
},
{ &hf_gtp_qos_arp_pvi,
{"Pre-emption Vulnerability (PVI)", "gtp.qos_arp_pvi",
FT_BOOLEAN, 16, TFS(&tfs_disabled_enabled), 0x01,
FT_BOOLEAN, 16, TFS(&tfs_disabled_enabled), 0x0001,
NULL, HFILL}
},
{&hf_gtp_qos_qci,

22
epan/dissectors/packet-ieee80211.c
View File

@ -42506,7 +42506,7 @@ proto_register_ieee80211(void)
{&hf_ieee80211_tclas_class_mask7_reserved,
{"Reserved", "wlan.tclas.class7.reserved",
FT_UINT24, BASE_HEX, NULL, 0xFFC0000, NULL, HFILL }},
FT_UINT24, BASE_HEX, NULL, 0xFFC000, NULL, HFILL }},
{&hf_ieee80211_tclas7_frame_control_spec,
{"Frame Control Spec", "wlan.tclas.class7.frame_control_spec",
@ -42637,24 +42637,24 @@ proto_register_ieee80211(void)
{&hf_ieee80211_tclas_class_mask9_frame_control_match_spec,
{"Frame Control Spec", "wlan.tclas.class9.frame_control_spec",
FT_UINT16, BASE_HEX, VALS(frame_control_mask_vals), 0x0003, NULL, HFILL }},
FT_UINT24, BASE_HEX, VALS(frame_control_mask_vals), 0x000003, NULL, HFILL }},
{&hf_ieee80211_tclas_class_mask9_address_1_match_spec,
{"Address 1 Spec", "wlan.tclas.class9.mask.address_1_spec",
FT_UINT16, BASE_HEX, VALS(address_1_mask_vals), 0x0003, NULL, HFILL }},
FT_UINT24, BASE_HEX, VALS(address_1_mask_vals), 0x000003, NULL, HFILL }},
{&hf_ieee80211_tclas_class_mask9_address_2_match_spec,
{"Address 2 Spec", "wlan.tclas.class9.mask.address_2_spec",
FT_UINT16, BASE_HEX, VALS(address_2_mask_vals), 0x00000C, NULL, HFILL }},
FT_UINT24, BASE_HEX, VALS(address_2_mask_vals), 0x00000C, NULL, HFILL }},
{&hf_ieee80211_tclas_class_mask9_sequence_control_spec,
{"Sequence Control Spec", "wlan.tclas.class9.mask.sequence_control_spec",
FT_UINT16, BASE_HEX, VALS(sequence_control_mask_vals),
0x0030, NULL, HFILL }},
FT_UINT24, BASE_HEX, VALS(sequence_control_mask_vals),
0x000030, NULL, HFILL }},
{&hf_ieee80211_tclas_class_mask9_reserved,
{"Reserved", "wlan.tclas.class9.mask.reserved",
FT_UINT16, BASE_HEX, NULL, 0xFFFFC0, NULL, HFILL }},
FT_UINT24, BASE_HEX, NULL, 0xFFFFC0, NULL, HFILL }},
{&hf_ieee80211_tclas9_frame_control_spec,
{"Frame Control Spec", "wlan.tclas.class9.frame_control_spec",
@ -43685,22 +43685,22 @@ proto_register_ieee80211(void)
{&hf_ieee80211_s1g_slot_def_slot_duration_count8,
{"Slot Duration Count",
"wlan.s1g.rps.raw_slot_definition.slot_duration_count",
FT_UINT16, BASE_DEC, NULL, 0x03FC0, NULL, HFILL }},
FT_UINT16, BASE_DEC, NULL, 0x03FC, NULL, HFILL }},
{&hf_ieee80211_s1g_slot_def_num_slots6,
{"Number of Slots",
"wlan.s1g.rps.raw_slot_definition.number_of_slots",
FT_UINT16, BASE_DEC, NULL, 0xFC0000, NULL, HFILL }},
FT_UINT16, BASE_DEC, NULL, 0xFC00, NULL, HFILL }},
{&hf_ieee80211_s1g_slot_def_slot_duration_count11,
{"Slot Duration Count",
"wlan.s1g.rps.raw_slot_definition.slot_duration_count",
FT_UINT16, BASE_DEC, NULL, 0x1FFC0, NULL, HFILL }},
FT_UINT16, BASE_DEC, NULL, 0x1FC0, NULL, HFILL }},
{&hf_ieee80211_s1g_slot_def_num_slots3,
{"Number of Slots",
"wlan.s1g.rps.raw_slot_definition.number_of_slots",
FT_UINT16, BASE_DEC, NULL, 0xE00000, NULL, HFILL }},
FT_UINT16, BASE_DEC, NULL, 0xE000, NULL, HFILL }},
{&hf_ieee80211_s1g_raw_start_time,
{"RAW Start Time", "wlan.s1g.raw_slot_definition.raw_start_time",

2
epan/dissectors/packet-isl.c
View File

@ -375,7 +375,7 @@ proto_register_isl(void)
FT_UINT16, BASE_HEX, NULL, 0x0,
"Route descriptor to be used for source learning", HFILL }},
{ &hf_isl_fcs_not_incl,
{ "FCS Not Included", "isl.fcs_not_incl", FT_BOOLEAN, 9,
{ "FCS Not Included", "isl.fcs_not_incl", FT_BOOLEAN, 8,
NULL, 0x40, NULL, HFILL }},
{ &hf_isl_esize,
{ "Esize", "isl.esize", FT_UINT8, BASE_DEC, NULL,

6
epan/dissectors/packet-mpeg1.c
View File

@ -193,7 +193,7 @@ proto_register_mpeg1(void)
FT_BOOLEAN,
16,
NULL,
0x20,
0x0020,
NULL, HFILL
}
},
@ -206,7 +206,7 @@ proto_register_mpeg1(void)
FT_BOOLEAN,
16,
NULL,
0x10,
0x0010,
NULL, HFILL
}
},
@ -219,7 +219,7 @@ proto_register_mpeg1(void)
FT_BOOLEAN,
16,
NULL,
0x08,
0x0008,
NULL, HFILL
}
},

24
epan/dissectors/packet-nfs.c
View File

@ -13869,51 +13869,51 @@ proto_register_nfs(void)
{ &hf_nfs3_mode_suid, {
"S_ISUID", "nfs.mode3.suid", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), 0x800, NULL, HFILL }},
TFS(&tfs_yes_no), 0x00000800, NULL, HFILL }},
{ &hf_nfs3_mode_sgid, {
"S_ISGID", "nfs.mode3.sgid", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), 0x400, NULL, HFILL }},
TFS(&tfs_yes_no), 0x00000400, NULL, HFILL }},
{ &hf_nfs3_mode_sticky, {
"S_ISVTX", "nfs.mode3.sticky", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), 0x200, NULL, HFILL }},
TFS(&tfs_yes_no), 0x00000200, NULL, HFILL }},
{ &hf_nfs3_mode_rusr, {
"S_IRUSR", "nfs.mode3.rusr", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), 0x100, NULL, HFILL }},
TFS(&tfs_yes_no), 0x00000100, NULL, HFILL }},
{ &hf_nfs3_mode_wusr, {
"S_IWUSR", "nfs.mode3.wusr", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), 0x080, NULL, HFILL }},
TFS(&tfs_yes_no), 0x00000080, NULL, HFILL }},
{ &hf_nfs3_mode_xusr, {
"S_IXUSR", "nfs.mode3.xusr", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), 0x040, NULL, HFILL }},
TFS(&tfs_yes_no), 0x00000040, NULL, HFILL }},
{ &hf_nfs3_mode_rgrp, {
"S_IRGRP", "nfs.mode3.rgrp", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), 0x020, NULL, HFILL }},
TFS(&tfs_yes_no), 0x00000020, NULL, HFILL }},
{ &hf_nfs3_mode_wgrp, {
"S_IWGRP", "nfs.mode3.wgrp", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), 0x010, NULL, HFILL }},
TFS(&tfs_yes_no), 0x00000010, NULL, HFILL }},
{ &hf_nfs3_mode_xgrp, {
"S_IXGRP", "nfs.mode3.xgrp", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), 0x008, NULL, HFILL }},
TFS(&tfs_yes_no), 0x00000008, NULL, HFILL }},
{ &hf_nfs3_mode_roth, {
"S_IROTH", "nfs.mode3.roth", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), 0x004, NULL, HFILL }},
TFS(&tfs_yes_no), 0x00000004, NULL, HFILL }},
{ &hf_nfs3_mode_woth, {
"S_IWOTH", "nfs.mode3.woth", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), 0x002, NULL, HFILL }},
TFS(&tfs_yes_no), 0x00000002, NULL, HFILL }},
{ &hf_nfs3_mode_xoth, {
"S_IXOTH", "nfs.mode3.xoth", FT_BOOLEAN, 32,
TFS(&tfs_yes_no), 0x001, NULL, HFILL }},
TFS(&tfs_yes_no), 0x00000001, NULL, HFILL }},
{ &hf_nfs2_ftype, {
"type", "nfs.ftype", FT_UINT32, BASE_DEC|BASE_EXT_STRING,

10
epan/dissectors/packet-ppi.c
View File

@ -1491,25 +1491,25 @@ proto_register_ppi(void)
FT_UINT32, BASE_HEX, NULL, 0x0, "PPI 802.3 Extension Flags", HFILL } },
{ &hf_8023_extension_flags_fcs_present,
{ "FCS Present Flag", "ppi.8023_extension.flags.fcs_present",
FT_BOOLEAN, 32, TFS(&tfs_true_false), 0x0001, "FCS (4 bytes) is present at the end of the packet", HFILL } },
FT_BOOLEAN, 32, TFS(&tfs_true_false), 0x00000001, "FCS (4 bytes) is present at the end of the packet", HFILL } },
{ &hf_8023_extension_errors,
{ "Errors", "ppi.8023_extension.errors",
FT_UINT32, BASE_HEX, NULL, 0x0, "PPI 802.3 Extension Errors", HFILL } },
{ &hf_8023_extension_errors_fcs,
{ "FCS Error", "ppi.8023_extension.errors.fcs",
FT_BOOLEAN, 32, TFS(&tfs_true_false), 0x0001,
FT_BOOLEAN, 32, TFS(&tfs_true_false), 0x00000001,
"PPI 802.3 Extension FCS Error", HFILL } },
{ &hf_8023_extension_errors_sequence,
{ "Sequence Error", "ppi.8023_extension.errors.sequence",
FT_BOOLEAN, 32, TFS(&tfs_true_false), 0x0002,
FT_BOOLEAN, 32, TFS(&tfs_true_false), 0x00000002,
"PPI 802.3 Extension Sequence Error", HFILL } },
{ &hf_8023_extension_errors_symbol,
{ "Symbol Error", "ppi.8023_extension.errors.symbol",
FT_BOOLEAN, 32, TFS(&tfs_true_false), 0x0004,
FT_BOOLEAN, 32, TFS(&tfs_true_false), 0x00000004,
"PPI 802.3 Extension Symbol Error", HFILL } },
{ &hf_8023_extension_errors_data,
{ "Data Error", "ppi.8023_extension.errors.data",
FT_BOOLEAN, 32, TFS(&tfs_true_false), 0x0008,
FT_BOOLEAN, 32, TFS(&tfs_true_false), 0x00000008,
"PPI 802.3 Extension Data Error", HFILL } },
/* Generated from convert_proto_tree_add_text.pl */

32
epan/dissectors/packet-sercosiii.c
View File

@ -1224,28 +1224,28 @@ proto_register_sercosiii(void)
},
{ &hf_siii_mdt_version_num_mdt_at_cp1_2,
{ "Number of MDTs and ATS in CP1 and CP2", "siii.mdt.version.num_mdt_at_cp1_2",
FT_UINT32, BASE_HEX, VALS(siii_mdt_version_num_mdtat_cp1_2_text), 0x30000,
FT_UINT32, BASE_HEX, VALS(siii_mdt_version_num_mdtat_cp1_2_text), 0x00030000,
NULL, HFILL }
},
{ &hf_siii_mdt_version_transmission_of_communication_parameters_mdt0_cp0,
{ "Transmission of Communication parameters", "siii.mdt.version.mdt0_cp0_transm_comm_parameter",
FT_BOOLEAN, 32, TFS(&tfs_yes_no), 0x100000,
FT_BOOLEAN, 32, TFS(&tfs_yes_no), 0x00100000,
NULL, HFILL }
},
{ &hf_siii_mdt_version_fast_cp_switch,
{ "Fast CP switch", "siii.mdt.version.mdt0_cp0_fast_cp_switch",
FT_BOOLEAN, 32, TFS(&siii_mdt_version_fast_cp_switch_text), 0x200000,
FT_BOOLEAN, 32, TFS(&siii_mdt_version_fast_cp_switch_text), 0x00200000,
NULL, HFILL }
},
{ &hf_siii_mdt_version_switch_off_sercos_telegrams,
{ "Switch off Sercos III telegrams", "siii.mdt.version.mdt0_cp0_switch_off_sercos_telegram",
FT_BOOLEAN, 32, TFS(&siii_switch_off_sercos_telegram_text), 0x400000,
FT_BOOLEAN, 32, TFS(&siii_switch_off_sercos_telegram_text), 0x00400000,
NULL, HFILL }
},
{ &hf_siii_mdt_version_initprocvers,
{ "Initialization Procedure Version Number", "siii.mdt.version.initprocvers",
FT_BOOLEAN, 32, TFS(&siii_mdt_version_initprocvers_text), 0xFF00,
FT_BOOLEAN, 32, TFS(&siii_mdt_version_initprocvers_text), 0x0000FF00,
NULL, HFILL }
},
@ -1357,37 +1357,37 @@ proto_register_sercosiii(void)
},
{ &hf_siii_mdt_svch_dbe,
{ "Data block element", "siii.mdt.svch.dbe",
FT_UINT16, BASE_DEC, VALS(siii_mdt_svch_dbe_text), 0x38,
FT_UINT16, BASE_DEC, VALS(siii_mdt_svch_dbe_text), 0x0038,
NULL, HFILL }
},
{ &hf_siii_mdt_svch_eot,
{"End of element transmission", "siii.mdt.svch.eot",
FT_BOOLEAN, 16, TFS(&siii_mdt_svch_eot_text), 0x04,
FT_BOOLEAN, 16, TFS(&siii_mdt_svch_eot_text), 0x0004,
NULL, HFILL }
},
{ &hf_siii_mdt_svch_rw,
{"Read/Write", "siii.mdt.svch.rw",
FT_BOOLEAN, 16, TFS(&siii_mdt_svch_rw_text), 0x02,
FT_BOOLEAN, 16, TFS(&siii_mdt_svch_rw_text), 0x0002,
NULL, HFILL }
},
{ &hf_siii_mdt_svch_mhs,
{"Master Handshake", "siii.mdt.svch.mhs",
FT_UINT16, BASE_DEC, NULL, 0x01,
FT_UINT16, BASE_DEC, NULL, 0x0001,
NULL, HFILL }
},
{ &hf_siii_at_svch_valid,
{ "SVC process", "siii.mdt.svch.proc",
FT_BOOLEAN, 16, TFS(&tfs_valid_not_valid), 0x08,
FT_BOOLEAN, 16, TFS(&tfs_valid_not_valid), 0x0008,
NULL, HFILL }
},
{ &hf_siii_at_svch_error,
{"SVC Error", "siii.mdt.svch.error",
FT_BOOLEAN, 16, TFS(&siii_at_svch_error_text), 0x04,
FT_BOOLEAN, 16, TFS(&siii_at_svch_error_text), 0x0004,
NULL, HFILL }
},
{ &hf_siii_at_svch_busy,
{"Busy", "siii.mdt.svch.busy",
FT_BOOLEAN, 16, TFS(&siii_at_svch_busy_text), 0x02,
FT_BOOLEAN, 16, TFS(&siii_at_svch_busy_text), 0x0002,
NULL, HFILL }
},
{ &hf_siii_at_svch_ahs,
@ -1503,23 +1503,23 @@ proto_register_sercosiii(void)
},
{ &hf_siii_mdt_hotplug_control_svc_switch,
{"Switch to SVC", "siii.mdt.hp.switch",
FT_UINT16, BASE_DEC, VALS(siii_mdt_hotplug_control_svc_switch_text), 0x100,
FT_UINT16, BASE_DEC, VALS(siii_mdt_hotplug_control_svc_switch_text), 0x0100,
NULL, HFILL }
},
{ &hf_siii_at_hotplug_status_param,
{"Parameter Received", "siii.at.hp.parameter",
FT_UINT16, BASE_DEC, VALS(siii_mdt_hotplug_status_ackcode_text), 0xFF,
FT_UINT16, BASE_DEC, VALS(siii_mdt_hotplug_status_ackcode_text), 0x00FF,
NULL, HFILL }
},
{ &hf_siii_at_hotplug_status_hp0_finished,
{"HP/SVC", "siii.at.hp.hp0_finished",
FT_UINT16, BASE_DEC, NULL, 0x100,
FT_UINT16, BASE_DEC, NULL, 0x0100,
NULL, HFILL }
},
{ &hf_siii_at_hotplug_status_error,
{"Error", "siii.at.hp.error",
FT_UINT16, BASE_DEC, VALS(siii_at_hotplug_status_error_text), 0x200,
FT_UINT16, BASE_DEC, VALS(siii_at_hotplug_status_error_text), 0x0200,
NULL, HFILL }
},
{ &hf_siii_service_channels,

12
epan/dissectors/packet-simple.c
View File

@ -576,25 +576,25 @@ void proto_register_simple(void)
{ "Relay Hop", "simple.status.relay_hop", FT_BYTES, BASE_NONE, NULL, 0x0,
NULL, HFILL }},
{ &hf_simple_status_dx_flag_system_messages,
{ "DX System Messages", "simple.status.dx_flag.system_messages", FT_BOOLEAN, 16, NULL, 0x1,
{ "DX System Messages", "simple.status.dx_flag.system_messages", FT_BOOLEAN, 16, NULL, 0x0001,
NULL, HFILL }},
{ &hf_simple_status_dx_flag_common_tims_bims,
{ "DX Common TIMS/BIMS", "simple.status.dx_flag.common_tims_bims", FT_BOOLEAN, 16, NULL, 0x2,
{ "DX Common TIMS/BIMS", "simple.status.dx_flag.common_tims_bims", FT_BOOLEAN, 16, NULL, 0x0002,
NULL, HFILL }},
{ &hf_simple_status_dx_flag_common_toms_boms,
{ "DX Common TOMS/BOMS", "simple.status.dx_flag.common_toms_boms", FT_BOOLEAN, 16, NULL, 0x4,
{ "DX Common TOMS/BOMS", "simple.status.dx_flag.common_toms_boms", FT_BOOLEAN, 16, NULL, 0x0004,
NULL, HFILL }},
{ &hf_simple_status_dx_flag_simple_receive,
{ "DX SIMPLE Receive", "simple.status.dx_flag.simple_receive", FT_BOOLEAN, 16, NULL, 0x8,
NULL, HFILL }},
{ &hf_simple_status_dx_flag_simple_transmit,
{ "DX SIMPLE Transmit", "simple.status.dx_flag.simple_transmit", FT_BOOLEAN, 16, NULL, 0x10,
{ "DX SIMPLE Transmit", "simple.status.dx_flag.simple_transmit", FT_BOOLEAN, 16, NULL, 0x0010,
NULL, HFILL }},
{ &hf_simple_status_dx_flag_all_tims_bims,
{ "DX All TIMS/BIMS", "simple.status.dx_flag.all_tims_bims", FT_BOOLEAN, 16, NULL, 0x20,
{ "DX All TIMS/BIMS", "simple.status.dx_flag.all_tims_bims", FT_BOOLEAN, 16, NULL, 0x0020,
NULL, HFILL }},
{ &hf_simple_status_dx_flag_all_toms_boms,
{ "DX All TOMS/BOMS", "simple.status.dx_flag.all_toms_boms", FT_BOOLEAN, 16, NULL, 0x40,
{ "DX All TOMS/BOMS", "simple.status.dx_flag.all_toms_boms", FT_BOOLEAN, 16, NULL, 0x0040,
NULL, HFILL }},
{ &hf_simple_status_dx_file_id,
{ "DX File Id", "simple.status.dx_file_id", FT_STRING, BASE_NONE, NULL, 0x0,

14
epan/dissectors/packet-smb.c
View File

@ -19181,23 +19181,23 @@ proto_register_smb(void)
{ &hf_smb_mac_sup_access_ctrl,
{ "Mac Access Control", "smb.mac.access_control", FT_BOOLEAN, 32,
TFS(&tfs_smb_mac_access_ctrl), 0x0010, "Are Mac Access Control Supported", HFILL }},
TFS(&tfs_smb_mac_access_ctrl), 0x00000010, "Are Mac Access Control Supported", HFILL }},
{ &hf_smb_mac_sup_getset_comments,
{ "Get Set Comments", "smb.mac.get_set_comments", FT_BOOLEAN, 32,
TFS(&tfs_smb_mac_getset_comments), 0x0020, "Are Mac Get Set Comments supported?", HFILL }},
TFS(&tfs_smb_mac_getset_comments), 0x00000020, "Are Mac Get Set Comments supported?", HFILL }},
{ &hf_smb_mac_sup_desktopdb_calls,
{ "Desktop DB Calls", "smb.mac.desktop_db_calls", FT_BOOLEAN, 32,
TFS(&tfs_smb_mac_desktopdb_calls), 0x0040, "Are Macintosh Desktop DB Calls Supported?", HFILL }},
TFS(&tfs_smb_mac_desktopdb_calls), 0x00000040, "Are Macintosh Desktop DB Calls Supported?", HFILL }},
{ &hf_smb_mac_sup_unique_ids,
{ "Macintosh Unique IDs", "smb.mac.uids", FT_BOOLEAN, 32,
TFS(&tfs_smb_mac_unique_ids), 0x0080, "Are Unique IDs supported", HFILL }},
TFS(&tfs_smb_mac_unique_ids), 0x00000080, "Are Unique IDs supported", HFILL }},
{ &hf_smb_mac_sup_streams,
{ "Mac Streams", "smb.mac.streams_support", FT_BOOLEAN, 32,
TFS(&tfs_smb_mac_streams), 0x0100, "Are Mac Extensions and streams supported?", HFILL }},
TFS(&tfs_smb_mac_streams), 0x00000100, "Are Mac Extensions and streams supported?", HFILL }},
{ &hf_smb_create_dos_date,
{ "Create Date", "smb.create.smb.date", FT_UINT16, BASE_HEX,
@ -20400,11 +20400,11 @@ proto_register_smb(void)
{ &hf_smb_get_dfs_server_hold_storage,
{ "Hold Storage", "smb.dfs.flags.server_hold_storage", FT_BOOLEAN, 16,
TFS(&tfs_get_dfs_server_hold_storage), 0x02, "The servers in referrals should hold storage for the file", HFILL }},
TFS(&tfs_get_dfs_server_hold_storage), 0x0002, "The servers in referrals should hold storage for the file", HFILL }},
{ &hf_smb_get_dfs_fielding,
{ "Fielding", "smb.dfs.flags.fielding", FT_BOOLEAN, 16,
TFS(&tfs_get_dfs_fielding), 0x01, "The servers in referrals are capable of fielding", HFILL }},
TFS(&tfs_get_dfs_fielding), 0x0001, "The servers in referrals are capable of fielding", HFILL }},
{ &hf_smb_dfs_referral_version,
{ "Version", "smb.dfs.referral.version", FT_UINT16, BASE_DEC,

10
epan/dissectors/packet-tns.c
View File

@ -1522,19 +1522,19 @@ void proto_register_tns(void)
NULL, 0x8, NULL, HFILL }},
{ &hf_tns_data_flag_more, {
"More Data to Come", "tns.data_flag.more", FT_BOOLEAN, 16,
NULL, 0x20, NULL, HFILL }},
NULL, 0x0020, NULL, HFILL }},
{ &hf_tns_data_flag_eof, {
"End of File", "tns.data_flag.eof", FT_BOOLEAN, 16,
NULL, 0x40, NULL, HFILL }},
NULL, 0x0040, NULL, HFILL }},
{ &hf_tns_data_flag_dic, {
"Do Immediate Confirmation", "tns.data_flag.dic", FT_BOOLEAN, 16,
NULL, 0x80, NULL, HFILL }},
NULL, 0x0080, NULL, HFILL }},
{ &hf_tns_data_flag_rts, {
"Request To Send", "tns.data_flag.rts", FT_BOOLEAN, 16,
NULL, 0x100, NULL, HFILL }},
NULL, 0x0100, NULL, HFILL }},
{ &hf_tns_data_flag_sntt, {
"Send NT Trailer", "tns.data_flag.sntt", FT_BOOLEAN, 16,
NULL, 0x200, NULL, HFILL }},
NULL, 0x0200, NULL, HFILL }},
{ &hf_tns_data_id, {
"Data ID", "tns.data_id", FT_UINT8, BASE_HEX,

24
epan/dissectors/packet-usb-ccid.c
View File

@ -786,10 +786,10 @@ proto_register_ccid(void)
NULL, 0x0, NULL, HFILL }},
{&hf_ccid_dwProtocols_t0,
{ "T=0", "usbccid.dwProtocols.t0", FT_BOOLEAN, 32,
TFS(&tfs_supported_not_supported), 0x01, NULL, HFILL }},
TFS(&tfs_supported_not_supported), 0x00000001, NULL, HFILL }},
{&hf_ccid_dwProtocols_t1,
{ "T=1", "usbccid.dwProtocols.t1", FT_BOOLEAN, 32,
TFS(&tfs_supported_not_supported), 0x02, NULL, HFILL }},
TFS(&tfs_supported_not_supported), 0x00000002, NULL, HFILL }},
{&hf_ccid_dwDefaultClock,
{ "default clock frequency", "usbccid.dwDefaultClock",
FT_UINT32, BASE_DEC|BASE_UNIT_STRING, &units_khz, 0x0, NULL, HFILL }},
@ -823,31 +823,31 @@ proto_register_ccid(void)
{&hf_ccid_dwFeatures_autoIccActivation,
{ "Automatic activation of ICC on inserting",
"usbccid.dwFeatures.autoIccActivation", FT_BOOLEAN, 32,
TFS(&tfs_supported_not_supported), 0x04, NULL, HFILL }},
TFS(&tfs_supported_not_supported), 0x00000004, NULL, HFILL }},
{&hf_ccid_dwFeatures_autoIccVoltSelect,
{ "Automatic ICC voltage selection",
"usbccid.dwFeatures.autoParamNegotiation", FT_BOOLEAN, 32,
TFS(&tfs_supported_not_supported), 0x08, NULL, HFILL }},
TFS(&tfs_supported_not_supported), 0x00000008, NULL, HFILL }},
{&hf_ccid_dwFeatures_autoParam,
{ "Automatic parameter configuration based on ATR",
"usbccid.dwFeatures.autoParam", FT_BOOLEAN, 32,
TFS(&tfs_supported_not_supported), 0x02, NULL, HFILL }},
TFS(&tfs_supported_not_supported), 0x00000002, NULL, HFILL }},
{&hf_ccid_dwFeatures_autoIccClk,
{ "Automatic ICC clock frequency change",
"usbccid.dwFeatures.autoIccClk", FT_BOOLEAN, 32,
TFS(&tfs_supported_not_supported), 0x10, NULL, HFILL }},
TFS(&tfs_supported_not_supported), 0x00000010, NULL, HFILL }},
{&hf_ccid_dwFeatures_autoBaudRate,
{ "Automatic baud rate change",
"usbccid.dwFeatures.autoBaudRate", FT_BOOLEAN, 32,
TFS(&tfs_supported_not_supported), 0x20, NULL, HFILL }},
TFS(&tfs_supported_not_supported), 0x00000020, NULL, HFILL }},
{&hf_ccid_dwFeatures_autoParamNegotiation,
{ "Automatic parameters negotiation",
"usbccid.dwFeatures.autoParamNegotiation", FT_BOOLEAN, 32,
TFS(&tfs_supported_not_supported), 0x40, NULL, HFILL }},
TFS(&tfs_supported_not_supported), 0x00000040, NULL, HFILL }},
{&hf_ccid_dwFeatures_autoPPS,
{ "Automatic PPS",
"usbccid.dwFeatures.autoPPS", FT_BOOLEAN, 32,
TFS(&tfs_supported_not_supported), 0x80, NULL, HFILL }},
TFS(&tfs_supported_not_supported), 0x00000080, NULL, HFILL }},
{&hf_ccid_dwFeatures_stopIccClk,
{ "CCID can set ICC in clock stop mode",
"usbccid.dwFeatures.stopIccClk", FT_BOOLEAN, 32,
@ -863,15 +863,15 @@ proto_register_ccid(void)
{&hf_ccid_dwFeatures_levelExchangeTDPU,
{ "TPDU level exchanges",
"usbccid.dwFeatures.levelExchangeTDPU", FT_BOOLEAN, 32,
TFS(&tfs_supported_not_supported), 0x010000, NULL, HFILL }},
TFS(&tfs_supported_not_supported), 0x00010000, NULL, HFILL }},
{&hf_ccid_dwFeatures_levelExchangeShortAPDU,
{ "Short APDU level exchange",
"usbccid.dwFeatures.levelExchangeShortAPDU", FT_BOOLEAN, 32,
TFS(&tfs_supported_not_supported), 0x020000, NULL, HFILL }},
TFS(&tfs_supported_not_supported), 0x00020000, NULL, HFILL }},
{&hf_ccid_dwFeatures_levelExchangeShortExtendedAPDU,
{ "Short and Extended APDU level exchange",
"usbccid.dwFeatures.levelExchangeShortExtendedAPDU", FT_BOOLEAN, 32,
TFS(&tfs_supported_not_supported), 0x040000, NULL, HFILL }},
TFS(&tfs_supported_not_supported), 0x00040000, NULL, HFILL }},
{&hf_ccid_dwFeatures_UsbWakeUp,
{ "USB Wake up signaling supported on card insertion and removal",
"usbccid.dwFeatures.UsbWakeUp", FT_BOOLEAN, 32,

8
epan/dissectors/packet-v120.c
View File

@ -273,19 +273,19 @@ proto_register_v120(void)
{ "Header", "v120.header", FT_UINT16, BASE_HEX, NULL, 0x0,
NULL, HFILL }},
{ &hf_v120_header_ext16,
{ "Extension octet", "v120.header.ext", FT_BOOLEAN, 16, TFS(&tfs_yes_no), 0x80,
{ "Extension octet", "v120.header.ext", FT_BOOLEAN, 16, TFS(&tfs_yes_no), 0x0080,
NULL, HFILL }},
{ &hf_v120_header_break16,
{ "Break condition", "v120.header.break", FT_BOOLEAN, 16, TFS(&tfs_yes_no), 0x40,
{ "Break condition", "v120.header.break", FT_BOOLEAN, 16, TFS(&tfs_yes_no), 0x0040,
NULL, HFILL }},
{ &hf_v120_header_error_control16,
{ "Error control C1/C2", "v120.error_control", FT_UINT16, BASE_HEX, NULL, 0x0C,
NULL, HFILL }},
{ &hf_v120_header_segb16,
{ "Bit B", "v120.header.segb", FT_BOOLEAN, 16, TFS(&tfs_segmentation_no_segmentation), 0x02,
{ "Bit B", "v120.header.segb", FT_BOOLEAN, 16, TFS(&tfs_segmentation_no_segmentation), 0x0002,
NULL, HFILL }},
{ &hf_v120_header_segf16,
{ "Bit F", "v120.header.segf", FT_BOOLEAN, 16, TFS(&tfs_segmentation_no_segmentation), 0x01,
{ "Bit F", "v120.header.segf", FT_BOOLEAN, 16, TFS(&tfs_segmentation_no_segmentation), 0x0001,
NULL, HFILL }},
{ &hf_v120_header_e,
{ "E", "v120.header.e", FT_BOOLEAN, 16, TFS(&tfs_yes_no), 0x8000,

2
epan/dissectors/packet-wccp.c
View File

@ -2824,7 +2824,7 @@ proto_register_wccp(void)
NULL, HFILL }
},
{ &hf_hash_flag_u,
{ "Hash information", "wccp.hash_flag.u", FT_BOOLEAN, 32, TFS(&tfs_historical_current), 0x10000,
{ "Hash information", "wccp.hash_flag.u", FT_BOOLEAN, 32, TFS(&tfs_historical_current), 0x00010000,
NULL, HFILL }
},
{ &hf_recvd_id,

2
epan/dissectors/packet-wifi-display.c
View File

@ -589,7 +589,7 @@ proto_register_wifi_display(void)
{ &hf_wfd_subelem_ext_capab_standby_resume_control,
{ "Standby and Resume Control",
"wifi_display.subelem.ext_capab.standby_resume_control",
FT_BOOLEAN, 16, TFS (&tfs_supported_not_supported), 0x008, NULL, HFILL }},
FT_BOOLEAN, 16, TFS (&tfs_supported_not_supported), 0x0008, NULL, HFILL }},
{ &hf_wfd_subelem_ext_capab_tdls_persistent,
{ "TDLS Persistent",
"wifi_display.subelem.ext_capab.tdls_persistent",

42
epan/dissectors/packet-wifi-nan.c
View File

@ -2912,70 +2912,70 @@ proto_register_nan(void)
{
"FSD Required",
"nan.sdea.ctr_fsd",
FT_BOOLEAN, 16, NULL, 0x001, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0001, NULL, HFILL
}
},
{ &hf_nan_attr_sdea_ctr_fsd_w_gas,
{
"FSD with GAS",
"nan.sdea.ctr_fsd_w_gas",
FT_BOOLEAN, 16, NULL, 0x002, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0002, NULL, HFILL
}
},
{ &hf_nan_attr_sdea_ctr_data_path,
{
"Data Path Required",
"nan.sdea.ctr_data_path",
FT_BOOLEAN, 16, NULL, 0x004, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0004, NULL, HFILL
}
},
{ &hf_nan_attr_sdea_ctr_data_path_type,
{
"Data Path Type",
"nan.sdea.ctr_data_path_type",
FT_BOOLEAN, 16, TFS(&sdea_ctr_data_path_type_flags), 0x008, NULL, HFILL
FT_BOOLEAN, 16, TFS(&sdea_ctr_data_path_type_flags), 0x0008, NULL, HFILL
}
},
{ &hf_nan_attr_sdea_ctr_reserved_multicast_type,
{
"Reserved (Multicast Type)",
"nan.sdea.ctr_reserved_multicast_type",
FT_BOOLEAN, 16, TFS(&sdea_ctr_reserved_multicast_type_flags), 0x010, NULL, HFILL
FT_BOOLEAN, 16, TFS(&sdea_ctr_reserved_multicast_type_flags), 0x0010, NULL, HFILL
}
},
{ &hf_nan_attr_sdea_ctr_qos,
{
"QoS Required",
"nan.sdea.ctr_qos",
FT_BOOLEAN, 16, NULL, 0x020, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0020, NULL, HFILL
}
},
{ &hf_nan_attr_sdea_ctr_security,
{
"Security Required",
"nan.sdea.ctr_security",
FT_BOOLEAN, 16, NULL, 0x040, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0040, NULL, HFILL
}
},
{ &hf_nan_attr_sdea_ctr_ranging,
{
"Ranging Required",
"nan.sdea.ctr_ranging",
FT_BOOLEAN, 16, NULL, 0x080, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0080, NULL, HFILL
}
},
{ &hf_nan_attr_sdea_ctr_range_limit,
{
"Range Limit Present",
"nan.sdea.ctr_range_limit",
FT_BOOLEAN, 16, NULL, 0x100, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0100, NULL, HFILL
}
},
{ &hf_nan_attr_sdea_ctr_service_update_indicator,
{
"Service Update Indicator Present",
"nan.sdea.ctr_service_update_indicator",
FT_BOOLEAN, 16, NULL, 0x200, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0200, NULL, HFILL
}
},
{ &hf_nan_attr_sdea_ingress_range_limit,
@ -3059,14 +3059,14 @@ proto_register_nan(void)
{
"IBSS",
"nan.connection_cap.ibss",
FT_BOOLEAN, 16, NULL, 0x10, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0010, NULL, HFILL
}
},
{ &hf_nan_attr_connection_cap_mesh,
{
"Mesh",
"nan.connection_cap.mesh",
FT_BOOLEAN, 16, NULL, 0x20, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0020, NULL, HFILL
}
},
{ &hf_nan_attr_wlan_infra_device_role,
@ -3493,49 +3493,49 @@ proto_register_nan(void)
{
"Map ID",
"nan.availability.map_id",
FT_UINT16, BASE_HEX_DEC, NULL, 0x00F, NULL, HFILL
FT_UINT16, BASE_HEX_DEC, NULL, 0x000F, NULL, HFILL
}
},
{ &hf_nan_attr_availability_committed_changed,
{
"Committed Changed",
"nan.availability.committed_changed",
FT_BOOLEAN, 16, NULL, 0x010, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0010, NULL, HFILL
}
},
{ &hf_nan_attr_availability_potential_changed,
{
"Potential Changed",
"nan.availability.potential_changed",
FT_BOOLEAN, 16, NULL, 0x020, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0020, NULL, HFILL
}
},
{ &hf_nan_attr_availability_public_availability_changed,
{
"Public Availability Attribute Changed",
"nan.availability.public_availability_changed",
FT_BOOLEAN, 16, NULL, 0x040, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0040, NULL, HFILL
}
},
{ &hf_nan_attr_availability_ndc_changed,
{
"NDC Attribute Changed",
"nan.availability.ndc_changed",
FT_BOOLEAN, 16, NULL, 0x080, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0080, NULL, HFILL
}
},
{ &hf_nan_attr_availability_reserved_multicast_schedule_changed,
{
"Reserved (Multicast Schedule Attribute Changed)",
"nan.availability.reserved_multicast_schedule_changed",
FT_BOOLEAN, 16, NULL, 0x100, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0100, NULL, HFILL
}
},
{ &hf_nan_attr_availability_reserved_multicast_schedule_change_changed,
{
"Reserved (Multicast Schedule Change Attribute Change Changed)",
"nan.availability.reserved_multicast_schedule_change_changed",
FT_BOOLEAN, 16, NULL, 0x200, NULL, HFILL
FT_BOOLEAN, 16, NULL, 0x0200, NULL, HFILL
}
},
{ &hf_nan_attr_availability_entry_len,
@ -3801,7 +3801,7 @@ proto_register_nan(void)
{
"Sequence ID",
"nan.unaligned_schedule.ctrl.sequence_id",
FT_UINT16, BASE_HEX_DEC, NULL, 0xF00, NULL, HFILL
FT_UINT16, BASE_HEX_DEC, NULL, 0x0F00, NULL, HFILL
}
},
{ &hf_nan_attr_unaligned_sch_starting_time,
@ -3976,7 +3976,7 @@ proto_register_nan(void)
{
"Min Delta FTM",
"nan.ranging_setup.ftm.min_delta_ftm",
FT_UINT24, BASE_HEX_DEC, NULL, 0x3F0, NULL, HFILL
FT_UINT24, BASE_HEX_DEC, NULL, 0x03F0, NULL, HFILL
}
},
{ &hf_nan_attr_ranging_setup_ftm_max_per_burst,

44
epan/dissectors/packet-windows-common.c
View File

@ -3398,82 +3398,82 @@ proto_do_register_windows_common(int proto_smb)
{ &hf_access_specific_15,
{ "Specific access, bit 15", "nt.access_mask.specific_15",
FT_BOOLEAN, 32, TFS(&tfs_set_notset),
0x8000, NULL, HFILL }},
0x00008000, NULL, HFILL }},
{ &hf_access_specific_14,
{ "Specific access, bit 14", "nt.access_mask.specific_14",
FT_BOOLEAN, 32, TFS(&tfs_set_notset),
0x4000, NULL, HFILL }},
0x00004000, NULL, HFILL }},
{ &hf_access_specific_13,
{ "Specific access, bit 13", "nt.access_mask.specific_13",
FT_BOOLEAN, 32, TFS(&tfs_set_notset),
0x2000, NULL, HFILL }},
0x00002000, NULL, HFILL }},
{ &hf_access_specific_12,
{ "Specific access, bit 12", "nt.access_mask.specific_12",
FT_BOOLEAN, 32, TFS(&tfs_set_notset),
0x1000, NULL, HFILL }},
0x00001000, NULL, HFILL }},
{ &hf_access_specific_11,
{ "Specific access, bit 11", "nt.access_mask.specific_11",
FT_BOOLEAN, 32, TFS(&tfs_set_notset),
0x0800, NULL, HFILL }},
0x00000800, NULL, HFILL }},
{ &hf_access_specific_10,
{ "Specific access, bit 10", "nt.access_mask.specific_10",
FT_BOOLEAN, 32, TFS(&tfs_set_notset),
0x0400, NULL, HFILL }},
0x00000400, NULL, HFILL }},
{ &hf_access_specific_9,
{ "Specific access, bit 9", "nt.access_mask.specific_9",
FT_BOOLEAN, 32, TFS(&tfs_set_notset),
0x0200, NULL, HFILL }},
0x00000200, NULL, HFILL }},
{ &hf_access_specific_8,
{ "Specific access, bit 8", "nt.access_mask.specific_8",
FT_BOOLEAN, 32, TFS(&tfs_set_notset),
0x0100, NULL, HFILL }},
0x00000100, NULL, HFILL }},
{ &hf_access_specific_7,
{ "Specific access, bit 7", "nt.access_mask.specific_7",
FT_BOOLEAN, 32, TFS(&tfs_set_notset),
0x0080, NULL, HFILL }},
0x00000080, NULL, HFILL }},
{ &hf_access_specific_6,
{ "Specific access, bit 6", "nt.access_mask.specific_6",
FT_BOOLEAN, 32, TFS(&tfs_set_notset),
0x0040, NULL, HFILL }},
0x00000040, NULL, HFILL }},
{ &hf_access_specific_5,
{ "Specific access, bit 5", "nt.access_mask.specific_5",
FT_BOOLEAN, 32, TFS(&tfs_set_notset),
0x0020, NULL, HFILL }},
0x00000020, NULL, HFILL }},
{ &hf_access_specific_4,
{ "Specific access, bit 4", "nt.access_mask.specific_4",
FT_BOOLEAN, 32, TFS(&tfs_set_notset),
0x0010, NULL, HFILL }},
0x00000010, NULL, HFILL }},
{ &hf_access_specific_3,
{ "Specific access, bit 3", "nt.access_mask.specific_3",
FT_BOOLEAN, 32, TFS(&tfs_set_notset),
0x0008, NULL, HFILL }},
0x00000008, NULL, HFILL }},
{ &hf_access_specific_2,
{ "Specific access, bit 2", "nt.access_mask.specific_2",
FT_BOOLEAN, 32, TFS(&tfs_set_notset),
0x0004, NULL, HFILL }},
0x00000004, NULL, HFILL }},
{ &hf_access_specific_1,
{ "Specific access, bit 1", "nt.access_mask.specific_1",
FT_BOOLEAN, 32, TFS(&tfs_set_notset),
0x0002, NULL, HFILL }},
0x00000002, NULL, HFILL }},
{ &hf_access_specific_0,
{ "Specific access, bit 0", "nt.access_mask.specific_0",
FT_BOOLEAN, 32, TFS(&tfs_set_notset),
0x0001, NULL, HFILL }},
0x00000001, NULL, HFILL }},
{ &hf_nt_ace_flags_object_type_present,
{ "Object Type Present", "nt.ace.object.flags.object_type_present",
@ -3587,27 +3587,27 @@ proto_do_register_windows_common(int proto_smb)
{ &hf_nt_ace_sra_flags_non_inheritable,
{ "Non-Inheritable", "nt.ace.sra.flags.non_inheritable", FT_BOOLEAN, 32,
TFS(&flags_ace_sra_info_non_inheritable), 0x0001, NULL, HFILL }},
TFS(&flags_ace_sra_info_non_inheritable), 0x00000001, NULL, HFILL }},
{ &hf_nt_ace_sra_flags_case_sensitive,
{ "Case Sensitive", "nt.ace.sra.flags.case_sensitive", FT_BOOLEAN, 32,
TFS(&flags_ace_sra_info_case_sensitive), 0x0002, NULL, HFILL }},
TFS(&flags_ace_sra_info_case_sensitive), 0x00000002, NULL, HFILL }},
{ &hf_nt_ace_sra_flags_deny_only,
{ "Deny Only", "nt.ace.sra.flags.deny_only", FT_BOOLEAN, 32,
TFS(&flags_ace_sra_info_deny_only), 0x0004, NULL, HFILL }},
TFS(&flags_ace_sra_info_deny_only), 0x00000004, NULL, HFILL }},
{ &hf_nt_ace_sra_flags_disabled_by_default,
{ "Disabled By Default", "nt.ace.sra.flags.disabled_by_default", FT_BOOLEAN, 32,
TFS(&flags_ace_sra_info_disabled_by_default), 0x0008, NULL, HFILL }},
TFS(&flags_ace_sra_info_disabled_by_default), 0x00000008, NULL, HFILL }},
{ &hf_nt_ace_sra_flags_disabled,
{ "Disabled", "nt.ace.sra.flags.disabled", FT_BOOLEAN, 32,
TFS(&flags_ace_sra_info_disabled), 0x0010, NULL, HFILL }},
TFS(&flags_ace_sra_info_disabled), 0x00000010, NULL, HFILL }},
{ &hf_nt_ace_sra_flags_mandatory,
{ "Mandatory", "nt.ace.sra.flags.mandatory", FT_BOOLEAN, 32,
TFS(&flags_ace_sra_info_mandatory), 0x0020, NULL, HFILL }},
TFS(&flags_ace_sra_info_mandatory), 0x00000020, NULL, HFILL }},
{ &hf_nt_ace_sra_value_count,
{ "Value Count", "nt.ace.sra.value_count", FT_UINT32, BASE_DEC, NULL, 0,

2
plugins/epan/profinet/packet-dcerpc-pn-io.c
View File

@ -14511,7 +14511,7 @@ proto_register_pn_io (void)
},
{ &hf_pn_RedundancyInfo_reserved,
{ "RedundancyInfo.reserved", "pn_io.srl_data.redundancyInfoReserved",
FT_UINT16, BASE_HEX, NULL, 0xFFFFFFFC,
FT_UINT16, BASE_HEX, NULL, 0xFFFC,
NULL, HFILL }
},
{ &hf_pn_io_number_of_ARDATAInfo,

52
tools/check_typed_item_calls.py
View File

@ -242,7 +242,7 @@ known_non_contiguous_fields = { 'wlan.fixed.capabilities.cfpoll.sta',
'ebhscr.eth.rsv', # matches other fields in same sequence
'v120.lli', # non-contiguous field (http://www.acacia-net.com/wwwcla/protocol/v120_l2.htm)
'stun.type.class',
'bssgp.csg_id',
'bssgp.csg_id', 'tiff.t6.unused', 'artnet.ip_prog_reply.unused',
'telnet.auth.mod.enc', 'osc.message.midi.bender', 'btle.data_header.rfu'
}
@ -276,12 +276,14 @@ class Item:
previousItem = None
def __init__(self, filename, filter, label, item_type, type_modifier, mask=None, check_mask=False, check_label=False, check_consecutive=False):
def __init__(self, filename, filter, label, item_type, type_modifier, mask=None,
check_mask=False, mask_exact_width=False, check_label=False, check_consecutive=False):
self.filename = filename
self.filter = filter
self.label = label
self.mask = mask
self.mask_exact_width = mask_exact_width
global warnings_found
@ -325,6 +327,11 @@ class Item:
self.check_digits_all_zeros(mask)
def __str__(self):
return 'Item ({0} "{1}" {2} type={3}:{4} mask={5})'.format(self.filename, self.label, self.filter, self.item_type, self.type_modifier, self.mask)
def set_mask_value(self):
try:
self.mask_read = True
@ -409,14 +416,16 @@ class Item:
return 8 # i.e. 1 byte
elif self.type_modifier == 'BASE_NONE':
return 8
elif self.type_modifier == 'SEP_DOT':
elif self.type_modifier == 'SEP_DOT': # from proto.h
return 64
else:
# Round up to next nibble.
# For FT_BOOLEAN, modifier is just numerical number of bits. Round up to next nibble.
return int(self.type_modifier)+3
else:
# Lookup fixed width for this type
return field_widths[self.item_type]
# N.B. Not currently used.
def check_mask_too_long(self, mask):
if not self.mask_value:
return
@ -432,27 +441,38 @@ class Item:
if mask.startswith('0x') and len(mask) > 3:
global warnings_found
global errors_found
if len(mask) % 2:
# Warn if odd number of digits/ TODO: only if >= 5?
if len(mask) % 2 and self.item_type != 'FT_BOOLEAN':
print('Warning:', self.filename, 'filter=', self.filter, ' - mask has odd number of digits', mask,
'expected max for', self.item_type, 'is', int((self.get_field_width_in_bits())/4))
warnings_found += 1
if self.item_type in field_widths:
# Longer than it should be?
if len(mask)-2 > self.get_field_width_in_bits()/4:
extra_digits = mask[2:2+(len(mask)-2 - int(self.get_field_width_in_bits()/4))]
# Its an error if any of these are non-zero, as they won't have any effect!
# Its definitely an error if any of these are non-zero, as they won't have any effect!
if extra_digits != '0'*len(extra_digits):
print('Error:', self.filename, 'filter=', self.filter, self.mask, "with len is", len(mask)-2,
"but type", self.item_type, " indicates max of", int(self.get_field_width_in_bits()/4),
"and extra digits are non-zero (" + extra_digits + ")")
errors_found += 1
else:
# If has leading zeros, still confusing, so warn.
print('Warning:', self.filename, 'filter=', self.filter, self.mask, "with len is", len(mask)-2,
# Has extra leading zeros, still confusing, so warn.
print('Warning:', self.filename, 'filter=', self.filter, self.mask, "with len", len(mask)-2,
"but type", self.item_type, " indicates max of", int(self.get_field_width_in_bits()/4))
warnings_found += 1
# Strict/fussy check - expecting mask length to match field width exactly!
# Currently only doing for FT_BOOLEAN
if self.mask_exact_width:
if self.item_type == 'FT_BOOLEAN' and len(mask)-2 != int(self.get_field_width_in_bits()/4):
print('Warning:', self.filename, 'filter=', self.filter, 'mask', self.mask, "with len", len(mask)-2,
"but type", self.item_type, "|", self.type_modifier, " indicates should be", int(self.get_field_width_in_bits()/4))
warnings_found += 1
else:
# This type shouldn't have a mask set at all.
print('Warning:', self.filename, 'filter=', self.filter, ' - item has type', self.item_type, 'but mask set:', mask)
warnings_found += 1
@ -600,6 +620,7 @@ def isGeneratedFile(filename):
f_read.close()
return False
if (line.find('Generated automatically') != -1 or
line.find('Generated Automatically') != -1 or
line.find('Autogenerated from') != -1 or
line.find('is autogenerated') != -1 or
line.find('automatically generated by Pidl') != -1 or
@ -617,14 +638,15 @@ def isGeneratedFile(filename):
return False
# Look for hf items (i.e. full item to be registered) in a dissector file.
def find_items(filename, check_mask=False, check_label=False, check_consecutive=False):
def find_items(filename, check_mask=False, mask_exact_width=False, check_label=False, check_consecutive=False):
is_generated = isGeneratedFile(filename)
items = {}
with open(filename, 'r') as f:
contents = f.read()
# Remove comments so as not to trip up RE.
contents = removeComments(contents)
matches = re.finditer(r'.*\{\s*\&(hf_[a-z_A-Z0-9]*)\s*,\s*{\s*\"(.+)\"\s*,\s*\"([a-zA-Z0-9_\-\.]+)\"\s*,\s*([a-zA-Z0-9_]*)\s*,\s*(.*)\s*,\s*([\&A-Za-z0-9x_<\|\s\(\)]*)\s*,\s*([ a-zA-Z0-9x_\<\~\|\(\)]*)\s*,', contents)
# N.B. re extends all the way to HFILL to avoid greedy matching
matches = re.finditer( r'.*\{\s*\&(hf_[a-z_A-Z0-9]*)\s*,\s*{\s*\"(.*)\"\s*,\s*\"([a-zA-Z0-9_\-\.]+)\"\s*,\s*([a-zA-Z0-9_]*)\s*,\s*(.*)\s*,\s*([\&A-Za-z0-9x\_<\|\s\(\)]*)\s*,\s*([a-zA-Z0-9x_]*)\s*,\s*.*\s*,\s*HFILL', contents)
for m in matches:
# Store this item.
hf = m.group(1)
@ -632,7 +654,9 @@ def find_items(filename, check_mask=False, check_label=False, check_consecutive=
type_modifier=m.group(5),
check_mask=check_mask,
check_label=check_label,
mask_exact_width=mask_exact_width,
check_consecutive=(not is_generated and check_consecutive))
#print('item is', hf, items[hf])
return items
@ -722,14 +746,14 @@ def findDissectorFilesInFolder(folder, dissector_files=None, recursive=False):
# Run checks on the given dissector file.
def checkFile(filename, check_mask=False, check_label=False, check_consecutive=False, check_missing_items=False, check_bitmask_fields=False):
def checkFile(filename, check_mask=False, mask_exact_width=False, check_label=False, check_consecutive=False, check_missing_items=False, check_bitmask_fields=False):
# Check file exists - e.g. may have been deleted in a recent commit.
if not os.path.exists(filename):
print(filename, 'does not exist!')
return
# Find important parts of items.
items_defined = find_items(filename, check_mask, check_label, check_consecutive)
items_defined = find_items(filename, check_mask, mask_exact_width, check_label, check_consecutive)
items_extern_declared = {}
items_declared = {}
@ -765,6 +789,8 @@ parser.add_argument('--open', action='store_true',
help='check open files')
parser.add_argument('--mask', action='store_true',
help='when set, check mask field too')
parser.add_argument('--mask-exact-width', action='store_true',
help='when set, check width of mask against field width')
parser.add_argument('--label', action='store_true',
help='when set, check label field too')
parser.add_argument('--consecutive', action='store_true',
@ -844,7 +870,7 @@ else:
for f in files:
if should_exit:
exit(1)
checkFile(f, check_mask=args.mask, check_label=args.label,
checkFile(f, check_mask=args.mask, mask_exact_width=args.mask_exact_width, check_label=args.label,
check_consecutive=args.consecutive, check_missing_items=args.missing_items,
check_bitmask_fields=args.check_bitmask_fields)