osmith
/
wireshark
forked from osmocom/wireshark
1
0
Fork 0
Code Pull Requests Releases Wiki Activity

Convert proto_tree_add_boolean to proto_tree_add_bitmask_[value|value_with_flags|list] 

Part 1 of a few

Change-Id: I413f23dfa92da5488ca8a7f62ca0738b25004635
Reviewed-on: https://code.wireshark.org/review/8117
Reviewed-by: Michael Mann <mmann78@netscape.net>
This commit is contained in:
Michael Mann 2015-04-16 22:40:34 -04:00
parent 8f9aa33b29
commit aeb9827e4a
17 changed files with 790 additions and 1981 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
epan/dissectors/packet-bgp.c
View File

@ -3244,6 +3244,15 @@ decode_link_state_attribute_tlv(proto_tree *tree, tvbuff_t *tvb, gint offset, pa
break; break;
case BGP_NLRI_TLV_NODE_FLAG_BITS: case BGP_NLRI_TLV_NODE_FLAG_BITS:
{
static const int * flags[] = {
&hf_bgp_ls_node_flag_bits_overload,
&hf_bgp_ls_node_flag_bits_attached,
&hf_bgp_ls_node_flag_bits_external,
&hf_bgp_ls_node_flag_bits_abr,
NULL
};
tlv_item = proto_tree_add_item(tree, hf_bgp_ls_tlv_node_flags_bits, tvb, offset, length+4, ENC_NA); tlv_item = proto_tree_add_item(tree, hf_bgp_ls_tlv_node_flags_bits, tvb, offset, length+4, ENC_NA);
tlv_tree = proto_item_add_subtree(tlv_item, ett_bgp_link_state); tlv_tree = proto_item_add_subtree(tlv_item, ett_bgp_link_state);
if(length != BGP_NLRI_TLV_LEN_NODE_FLAG_BITS){ if(length != BGP_NLRI_TLV_LEN_NODE_FLAG_BITS){
@ -3253,15 +3262,12 @@ decode_link_state_attribute_tlv(proto_tree *tree, tvbuff_t *tvb, gint offset, pa
} }
proto_tree_add_item(tlv_tree, hf_bgp_ls_type, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_item(tlv_tree, hf_bgp_ls_type, tvb, offset, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(tlv_tree, hf_bgp_ls_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN); proto_tree_add_item(tlv_tree, hf_bgp_ls_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN);
tmp8 = tvb_get_guint8(tvb, offset); proto_tree_add_bitmask_list(tlv_tree, tvb, offset+4, 1, flags, ENC_NA);
proto_tree_add_boolean(tlv_tree, hf_bgp_ls_node_flag_bits_overload, tvb, offset, 1, tmp8); tmp8 = tvb_get_guint8(tvb, offset+4) & 0x0f;
proto_tree_add_boolean(tlv_tree, hf_bgp_ls_node_flag_bits_attached, tvb, offset, 1, tmp8);
proto_tree_add_boolean(tlv_tree, hf_bgp_ls_node_flag_bits_external, tvb, offset, 1, tmp8);
proto_tree_add_boolean(tlv_tree, hf_bgp_ls_node_flag_bits_abr, tvb, offset, 1, tmp8);
tmp8 &= 0x0f;
if(tmp8){ if(tmp8){
expert_add_info_format(pinfo, tlv_tree, &ei_bgp_ls_error, "Reserved flag bits are not set to zero (%u).", tmp8); expert_add_info_format(pinfo, tlv_tree, &ei_bgp_ls_error, "Reserved flag bits are not set to zero (%u).", tmp8);
} }
}
break; break;
case BGP_NLRI_TLV_OPAQUE_NODE_PROPERTIES: case BGP_NLRI_TLV_OPAQUE_NODE_PROPERTIES:
@ -3454,6 +3460,13 @@ decode_link_state_attribute_tlv(proto_tree *tree, tvbuff_t *tvb, gint offset, pa
} }
break; break;
case BGP_NLRI_TLV_MPLS_PROTOCOL_MASK: case BGP_NLRI_TLV_MPLS_PROTOCOL_MASK:
{
static const int * flags[] = {
&hf_bgp_ls_mpls_protocol_mask_flag_l,
&hf_bgp_ls_mpls_protocol_mask_flag_r,
NULL
};
tlv_item = proto_tree_add_item(tree, hf_bgp_ls_tlv_mpls_protocol_mask, tvb, offset, length+4, ENC_NA); tlv_item = proto_tree_add_item(tree, hf_bgp_ls_tlv_mpls_protocol_mask, tvb, offset, length+4, ENC_NA);
tlv_tree = proto_item_add_subtree(tlv_item, ett_bgp_link_state); tlv_tree = proto_item_add_subtree(tlv_item, ett_bgp_link_state);
if(length != BGP_NLRI_TLV_LEN_MPLS_PROTOCOL_MASK){ if(length != BGP_NLRI_TLV_LEN_MPLS_PROTOCOL_MASK){
@ -3463,14 +3476,13 @@ decode_link_state_attribute_tlv(proto_tree *tree, tvbuff_t *tvb, gint offset, pa
} }
proto_tree_add_item(tlv_tree, hf_bgp_ls_type, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_item(tlv_tree, hf_bgp_ls_type, tvb, offset, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(tlv_tree, hf_bgp_ls_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN); proto_tree_add_item(tlv_tree, hf_bgp_ls_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN);
tmp8 = tvb_get_guint8(tvb, offset + 4); proto_tree_add_bitmask_list(tlv_tree, tvb, offset+4, 1, flags, ENC_NA);
proto_tree_add_boolean(tlv_tree, hf_bgp_ls_mpls_protocol_mask_flag_l, tvb, offset + 4, 1, tmp8); tmp8 = tvb_get_guint8(tvb, offset + 4) & 0x3f;
proto_tree_add_boolean(tlv_tree, hf_bgp_ls_mpls_protocol_mask_flag_r, tvb, offset + 4, 1, tmp8);
tmp8 &= 0x3f;
if(tmp8){ if(tmp8){
proto_tree_add_expert_format(tlv_tree, pinfo, &ei_bgp_ls_error, tvb, offset + 4, 1, proto_tree_add_expert_format(tlv_tree, pinfo, &ei_bgp_ls_error, tvb, offset + 4, 1,
"Reserved flags are not set to zero (%u).", tmp8); "Reserved flags are not set to zero (%u).", tmp8);
} }
}
break; break;
case BGP_NLRI_TLV_METRIC: case BGP_NLRI_TLV_METRIC:
tlv_item = proto_tree_add_item(tree, hf_bgp_ls_tlv_metric, tvb, offset, length+4, ENC_NA); tlv_item = proto_tree_add_item(tree, hf_bgp_ls_tlv_metric, tvb, offset, length+4, ENC_NA);
@ -3527,9 +3539,8 @@ decode_link_state_attribute_tlv(proto_tree *tree, tvbuff_t *tvb, gint offset, pa
} }
proto_tree_add_item(tlv_tree, hf_bgp_ls_type, tvb, offset, 2, ENC_BIG_ENDIAN); proto_tree_add_item(tlv_tree, hf_bgp_ls_type, tvb, offset, 2, ENC_BIG_ENDIAN);
proto_tree_add_item(tlv_tree, hf_bgp_ls_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN); proto_tree_add_item(tlv_tree, hf_bgp_ls_length, tvb, offset + 2, 2, ENC_BIG_ENDIAN);
tmp8 = tvb_get_guint8(tvb, offset + 4); proto_tree_add_item(tlv_tree, hf_bgp_ls_igp_flags_flag_d, tvb, offset + 4, 1, ENC_NA);
proto_tree_add_boolean(tlv_tree, hf_bgp_ls_igp_flags_flag_d, tvb, offset + 4, 1, tmp8); tmp8 = tvb_get_guint8(tvb, offset + 4) & 0x7F;
tmp8 &= 0x7F;
if(tmp8){ if(tmp8){
expert_add_info_format(pinfo, tlv_tree, &ei_bgp_ls_error, "Reserved flags are not set to zero (%u).", tmp8); expert_add_info_format(pinfo, tlv_tree, &ei_bgp_ls_error, "Reserved flags are not set to zero (%u).", tmp8);
} }

148
epan/dissectors/packet-bpdu.c
View File

@ -232,13 +232,6 @@ static const value_string role_vals[] = {
static const char initial_sep[] = " ("; static const char initial_sep[] = " (";
static const char cont_sep[] = ", "; static const char cont_sep[] = ", ";
#define APPEND_BOOLEAN_FLAG(flag, item, string) \
if(flag){ \
if(item) \
proto_item_append_text(item, string, sep); \
sep = cont_sep; \
}
static void static void
dissect_bpdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean is_bpdu_pvst); dissect_bpdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean is_bpdu_pvst);
@ -355,14 +348,29 @@ dissect_bpdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean is_bp
proto_tree *mstp_tree, *msti_tree, *spt_tree = NULL, *aux_mcid_tree = NULL, *agreement_tree = NULL; proto_tree *mstp_tree, *msti_tree, *spt_tree = NULL, *aux_mcid_tree = NULL, *agreement_tree = NULL;
proto_item *bpdu_item; proto_item *bpdu_item;
proto_item *agreement_item; proto_item *agreement_item;
proto_tree *flags_tree;
proto_item *flags_item;
proto_tree *root_id_tree; proto_tree *root_id_tree;
proto_tree *bridge_id_tree; proto_tree *bridge_id_tree;
proto_tree *cist_bridge_id_tree; proto_tree *cist_bridge_id_tree;
proto_item *hidden_item; proto_item *hidden_item;
const char *sep; const char *sep;
static const int * bpdu_flags[] = {
&hf_bpdu_flags_tcack,
&hf_bpdu_flags_tc,
NULL
};
static const int * rst_flags[] = {
&hf_bpdu_flags_tcack,
&hf_bpdu_flags_agreement,
&hf_bpdu_flags_forwarding,
&hf_bpdu_flags_learning,
&hf_bpdu_flags_port_role,
&hf_bpdu_flags_proposal,
&hf_bpdu_flags_tc,
NULL
};
/* GARP application frames require special interpretation of the /* GARP application frames require special interpretation of the
destination address field; otherwise, they will be mistaken as destination address field; otherwise, they will be mistaken as
BPDU frames. BPDU frames.
@ -539,50 +547,10 @@ dissect_bpdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean is_bp
} }
bridge_identifier_mac_str = tvb_ether_to_str(tvb, BPDU_BRIDGE_IDENTIFIER + 2); bridge_identifier_mac_str = tvb_ether_to_str(tvb, BPDU_BRIDGE_IDENTIFIER + 2);
flags_item = proto_tree_add_uint(bpdu_tree, hf_bpdu_flags, tvb,
BPDU_FLAGS, 1, flags);
flags_tree = proto_item_add_subtree(flags_item, ett_bpdu_flags);
sep = initial_sep;
APPEND_BOOLEAN_FLAG(flags & BPDU_FLAGS_TCACK, flags_item,
"%sTopology Change Acknowledgment");
proto_tree_add_boolean(flags_tree, hf_bpdu_flags_tcack, tvb,
BPDU_FLAGS, 1, flags);
if (bpdu_type == BPDU_TYPE_RST) { if (bpdu_type == BPDU_TYPE_RST) {
APPEND_BOOLEAN_FLAG(flags & BPDU_FLAGS_AGREEMENT, flags_item, proto_tree_add_bitmask_value_with_flags(bpdu_tree, tvb, BPDU_FLAGS, hf_bpdu_flags, ett_bpdu_flags, rst_flags, flags, BMT_NO_FALSE|BMT_NO_TFS);
"%sAgreement"); } else {
proto_tree_add_boolean(flags_tree, hf_bpdu_flags_agreement, tvb, proto_tree_add_bitmask_value_with_flags(bpdu_tree, tvb, BPDU_FLAGS, hf_bpdu_flags, ett_bpdu_flags, bpdu_flags, flags, BMT_NO_FALSE|BMT_NO_TFS);
BPDU_FLAGS, 1, flags);
APPEND_BOOLEAN_FLAG(flags & BPDU_FLAGS_FORWARDING, flags_item,
"%sForwarding");
proto_tree_add_boolean(flags_tree, hf_bpdu_flags_forwarding, tvb,
BPDU_FLAGS, 1, flags);
APPEND_BOOLEAN_FLAG(flags & BPDU_FLAGS_LEARNING, flags_item,
"%sLearning");
proto_tree_add_boolean(flags_tree, hf_bpdu_flags_learning, tvb,
BPDU_FLAGS, 1, flags);
if (flags_item) {
guint8 port_role;
port_role = (flags & BPDU_FLAGS_PORT_ROLE_MASK) >> BPDU_FLAGS_PORT_ROLE_SHIFT;
proto_item_append_text(flags_item, "%sPort Role: %s", sep,
val_to_str(port_role, role_vals,
"Unknown (%u)"));
}
sep = cont_sep;
proto_tree_add_uint(flags_tree, hf_bpdu_flags_port_role, tvb,
BPDU_FLAGS, 1, flags);
APPEND_BOOLEAN_FLAG(flags & BPDU_FLAGS_PROPOSAL, flags_item,
"%sProposal");
proto_tree_add_boolean(flags_tree, hf_bpdu_flags_proposal, tvb,
BPDU_FLAGS, 1, flags);
}
APPEND_BOOLEAN_FLAG(flags & BPDU_FLAGS_TC, flags_item,
"%sTopology Change");
proto_tree_add_boolean(flags_tree, hf_bpdu_flags_tc, tvb,
BPDU_FLAGS, 1, flags);
if (sep != initial_sep) {
/* We put something in; put in the terminating ")" */
proto_item_append_text(flags_item, ")");
} }
/* add Identifier with format based on preference value /* add Identifier with format based on preference value
@ -886,43 +854,7 @@ dissect_bpdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean is_bp
msti_regional_root_mac_str); msti_regional_root_mac_str);
/* flags */ /* flags */
flags = tvb_get_guint8(tvb, offset+MSTI_FLAGS); proto_tree_add_bitmask_with_flags(msti_tree, tvb, offset+MSTI_FLAGS, hf_bpdu_msti_flags, ett_bpdu_flags, rst_flags, ENC_NA, BMT_NO_FALSE|BMT_NO_TFS);
flags_item = proto_tree_add_uint(msti_tree, hf_bpdu_msti_flags, tvb,
offset+MSTI_FLAGS, 1, flags);
flags_tree = proto_item_add_subtree(flags_item, ett_bpdu_flags);
sep = initial_sep;
APPEND_BOOLEAN_FLAG(flags & BPDU_FLAGS_TCACK, flags_item, "%sMaster");
proto_tree_add_boolean(flags_tree, hf_bpdu_flags_tcack, tvb,
offset+MSTI_FLAGS, 1, flags);
APPEND_BOOLEAN_FLAG(flags & BPDU_FLAGS_AGREEMENT, flags_item, "%sAgreement");
proto_tree_add_boolean(flags_tree, hf_bpdu_flags_agreement, tvb,
offset+MSTI_FLAGS, 1, flags);
APPEND_BOOLEAN_FLAG(flags & BPDU_FLAGS_FORWARDING, flags_item, "%sForwarding");
proto_tree_add_boolean(flags_tree, hf_bpdu_flags_forwarding, tvb,
offset+MSTI_FLAGS, 1, flags);
APPEND_BOOLEAN_FLAG(flags & BPDU_FLAGS_LEARNING, flags_item, "%sLearning");
proto_tree_add_boolean(flags_tree, hf_bpdu_flags_learning, tvb,
offset+MSTI_FLAGS, 1, flags);
if (flags_item) {
guint8 port_role;
port_role = (flags & BPDU_FLAGS_PORT_ROLE_MASK) >> BPDU_FLAGS_PORT_ROLE_SHIFT;
proto_item_append_text(flags_item, "%sPort Role: %s", sep,
val_to_str(port_role, role_vals,
"Unknown (%u)"));
}
proto_tree_add_uint(flags_tree, hf_bpdu_flags_port_role, tvb,
offset+MSTI_FLAGS, 1, flags);
sep = cont_sep;
APPEND_BOOLEAN_FLAG(flags & BPDU_FLAGS_PROPOSAL, flags_item, "%sProposal");
proto_tree_add_boolean(flags_tree, hf_bpdu_flags_proposal, tvb,
offset+MSTI_FLAGS, 1, flags);
APPEND_BOOLEAN_FLAG(flags & BPDU_FLAGS_TC, flags_item, "%sTopology Change");
proto_tree_add_boolean(flags_tree, hf_bpdu_flags_tc, tvb,
offset+MSTI_FLAGS, 1, flags);
if (sep != initial_sep) { /* We put something in; put in the terminating ")" */
proto_item_append_text(flags_item, ")");
}
/* pri, MSTID, Regional root */ /* pri, MSTID, Regional root */
hidden_item = proto_tree_add_item(msti_tree, hf_bpdu_msti_regional_root_mac, tvb, hidden_item = proto_tree_add_item(msti_tree, hf_bpdu_msti_regional_root_mac, tvb,
@ -973,43 +905,7 @@ dissect_bpdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean is_bp
"MSTID: %d", msti_mstid); "MSTID: %d", msti_mstid);
/* flags */ /* flags */
flags = tvb_get_guint8(tvb, offset+ALT_MSTI_FLAGS); proto_tree_add_bitmask_with_flags(msti_tree, tvb, offset+ALT_MSTI_FLAGS, hf_bpdu_msti_flags, ett_bpdu_flags, rst_flags, ENC_NA, BMT_NO_FALSE|BMT_NO_TFS);
flags_item = proto_tree_add_uint(msti_tree, hf_bpdu_msti_flags, tvb,
offset+ALT_MSTI_FLAGS, 1, flags);
flags_tree = proto_item_add_subtree(flags_item, ett_bpdu_flags);
sep = initial_sep;
APPEND_BOOLEAN_FLAG(flags & BPDU_FLAGS_TCACK, flags_item, "%sMaster");
proto_tree_add_boolean(flags_tree, hf_bpdu_flags_tcack, tvb,
offset+ALT_MSTI_FLAGS, 1, flags);
APPEND_BOOLEAN_FLAG(flags & BPDU_FLAGS_AGREEMENT, flags_item, "%sAgreement");
proto_tree_add_boolean(flags_tree, hf_bpdu_flags_agreement, tvb,
offset+ALT_MSTI_FLAGS, 1, flags);
APPEND_BOOLEAN_FLAG(flags & BPDU_FLAGS_FORWARDING, flags_item, "%sForwarding");
proto_tree_add_boolean(flags_tree, hf_bpdu_flags_forwarding, tvb,
offset+ALT_MSTI_FLAGS, 1, flags);
APPEND_BOOLEAN_FLAG(flags & BPDU_FLAGS_LEARNING, flags_item, "%sLearning");
proto_tree_add_boolean(flags_tree, hf_bpdu_flags_learning, tvb,
offset+ALT_MSTI_FLAGS, 1, flags);
if (flags_item) {
guint8 port_role;
port_role = (flags & BPDU_FLAGS_PORT_ROLE_MASK) >> BPDU_FLAGS_PORT_ROLE_SHIFT;
proto_item_append_text(flags_item, "%sPort Role: %s", sep,
val_to_str(port_role, role_vals,
"Unknown (%u)"));
}
proto_tree_add_uint(flags_tree, hf_bpdu_flags_port_role, tvb,
offset+ALT_MSTI_FLAGS, 1, flags);
sep = cont_sep;
APPEND_BOOLEAN_FLAG(flags & BPDU_FLAGS_PROPOSAL, flags_item, "%sProposal");
proto_tree_add_boolean(flags_tree, hf_bpdu_flags_proposal, tvb,
offset+ALT_MSTI_FLAGS, 1, flags);
APPEND_BOOLEAN_FLAG(flags & BPDU_FLAGS_TC, flags_item, "%sTopology Change");
proto_tree_add_boolean(flags_tree, hf_bpdu_flags_tc, tvb,
offset+ALT_MSTI_FLAGS, 1, flags);
if (sep != initial_sep) { /* We put something in; put in the terminating ")" */
proto_item_append_text(flags_item, ")");
}
/* pri, MSTID, Regional root */ /* pri, MSTID, Regional root */
hidden_item = proto_tree_add_item(msti_tree, hf_bpdu_msti_regional_root_mac, tvb, hidden_item = proto_tree_add_item(msti_tree, hf_bpdu_msti_regional_root_mac, tvb,

68
epan/dissectors/packet-brdwlk.c
View File

@ -140,63 +140,19 @@ static const true_false_string tfs_error_ctrl = {
static void static void
dissect_brdwlk_err(proto_tree *parent_tree, tvbuff_t *tvb, int offset) dissect_brdwlk_err(proto_tree *parent_tree, tvbuff_t *tvb, int offset)
{ {
proto_item *item; static const int * flags[] = {
proto_tree *tree; &hf_brdwlk_error_plp,
guint8 flags; &hf_brdwlk_error_ef,
&hf_brdwlk_error_nd,
&hf_brdwlk_error_tr,
&hf_brdwlk_error_badcrc,
&hf_brdwlk_error_ff,
&hf_brdwlk_error_jumbo,
&hf_brdwlk_error_ctrl,
NULL
};
flags = tvb_get_guint8(tvb, offset); proto_tree_add_bitmask_with_flags(parent_tree, tvb, offset, hf_brdwlk_error, ett_brdwlk_error, flags, ENC_NA, BMT_NO_FALSE|BMT_NO_TFS);
item = proto_tree_add_uint(parent_tree, hf_brdwlk_error,
tvb, offset, 1, flags);
tree = proto_item_add_subtree(item, ett_brdwlk_error);
proto_tree_add_boolean(tree, hf_brdwlk_error_plp, tvb, offset, 1, flags);
if (flags & 0x01) {
proto_item_append_text(item, " Packet Length Present");
}
flags &= (~( 0x01 ));
proto_tree_add_boolean(tree, hf_brdwlk_error_ef, tvb, offset, 1, flags);
if (flags & 0x02) {
proto_item_append_text(item, " Empty Frame");
}
flags &= (~( 0x02 ));
proto_tree_add_boolean(tree, hf_brdwlk_error_nd, tvb, offset, 1, flags);
if (flags & 0x04) {
proto_item_append_text(item, " No Data");
}
flags &= (~( 0x04 ));
proto_tree_add_boolean(tree, hf_brdwlk_error_tr, tvb, offset, 1, flags);
if (flags & 0x08) {
proto_item_append_text(item, " Truncated");
}
flags &= (~( 0x08 ));
proto_tree_add_boolean(tree, hf_brdwlk_error_badcrc, tvb, offset, 1, flags);
if (flags & 0x10) {
proto_item_append_text(item, " Bad FC CRC");
}
flags &= (~( 0x10 ));
proto_tree_add_boolean(tree, hf_brdwlk_error_ff, tvb, offset, 1, flags);
if (flags & 0x20) {
proto_item_append_text(item, " Fifo Full");
}
flags &= (~( 0x20 ));
proto_tree_add_boolean(tree, hf_brdwlk_error_jumbo, tvb, offset, 1, flags);
if (flags & 0x40) {
proto_item_append_text(item, " Jumbo FC Frame");
}
flags &= (~( 0x40 ));
proto_tree_add_boolean(tree, hf_brdwlk_error_ctrl, tvb, offset, 1, flags);
if (flags & 0x80) {
proto_item_append_text(item, " Ctrl Char Inside Frame");
}
/*flags &= (~( 0x80 ));*/
} }
/* Code to actually dissect the packets */ /* Code to actually dissect the packets */

63
epan/dissectors/packet-bthfp.c
View File

@ -694,7 +694,6 @@ dissect_brsf_parameter(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
gint offset, gint role, guint16 type, guint8 *parameter_stream, gint offset, gint role, guint16 type, guint8 *parameter_stream,
guint parameter_number, gint parameter_length, void **data _U_) guint parameter_number, gint parameter_length, void **data _U_)
{ {
proto_tree *ptree;
proto_item *pitem; proto_item *pitem;
guint32 value; guint32 value;
@ -708,42 +707,44 @@ dissect_brsf_parameter(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
value = get_uint_parameter(parameter_stream, parameter_length); value = get_uint_parameter(parameter_stream, parameter_length);
if (role == ROLE_HS) { if (role == ROLE_HS) {
pitem = proto_tree_add_uint(tree, hf_brsf_hs, tvb, offset, parameter_length, value); static const int * hs[] = {
ptree = proto_item_add_subtree(pitem, ett_bthfp_brsf_hf); &hf_brsf_hs_ec_nr_function,
&hf_brsf_hs_call_waiting_or_tree_way,
proto_tree_add_boolean(ptree, hf_brsf_hs_ec_nr_function, tvb, offset, parameter_length, value); &hf_brsf_hs_cli_presentation,
proto_tree_add_boolean(ptree, hf_brsf_hs_call_waiting_or_tree_way, tvb, offset, parameter_length, value); &hf_brsf_hs_voice_recognition_activation,
proto_tree_add_boolean(ptree, hf_brsf_hs_cli_presentation, tvb, offset, parameter_length, value); &hf_brsf_hs_remote_volume_control,
proto_tree_add_boolean(ptree, hf_brsf_hs_voice_recognition_activation, tvb, offset, parameter_length, value); &hf_brsf_hs_enhanced_call_status,
proto_tree_add_boolean(ptree, hf_brsf_hs_remote_volume_control, tvb, offset, parameter_length, value); &hf_brsf_hs_enhanced_call_control,
proto_tree_add_boolean(ptree, hf_brsf_hs_enhanced_call_status, tvb, offset, parameter_length, value); &hf_brsf_hs_codec_negotiation,
proto_tree_add_boolean(ptree, hf_brsf_hs_enhanced_call_control, tvb, offset, parameter_length, value); &hf_brsf_hs_hf_indicators,
proto_tree_add_boolean(ptree, hf_brsf_hs_codec_negotiation, tvb, offset, parameter_length, value); &hf_brsf_hs_esco_s4_t2_settings_support,
proto_tree_add_boolean(ptree, hf_brsf_hs_hf_indicators, tvb, offset, parameter_length, value); &hf_brsf_hs_reserved,
proto_tree_add_boolean(ptree, hf_brsf_hs_esco_s4_t2_settings_support, tvb, offset, parameter_length, value); NULL
pitem = proto_tree_add_uint(ptree, hf_brsf_hs_reserved, tvb, offset, parameter_length, value); };
pitem = proto_tree_add_bitmask_value_with_flags(tree, tvb, offset, hf_brsf_hs, ett_bthfp_brsf_hf, hs, value, BMT_NO_APPEND);
if (value >> 8) { if (value >> 8) {
expert_add_info(pinfo, pitem, &ei_brfs_hs_reserved_bits); expert_add_info(pinfo, pitem, &ei_brfs_hs_reserved_bits);
} }
} else { } else {
pitem = proto_tree_add_uint(tree, hf_brsf_ag, tvb, offset, parameter_length, value); static const int * ag[] = {
ptree = proto_item_add_subtree(pitem, ett_bthfp_brsf_ag); &hf_brsf_ag_three_way_calling,
&hf_brsf_ag_ec_nr_function,
&hf_brsf_ag_voice_recognition_function,
&hf_brsf_ag_inband_ring_tone,
&hf_brsf_ag_attach_number_to_voice_tag,
&hf_brsf_ag_ability_to_reject_a_call,
&hf_brsf_ag_enhanced_call_status,
&hf_brsf_ag_enhanced_call_control,
&hf_brsf_ag_extended_error_result_codes,
&hf_brsf_ag_codec_negotiation,
&hf_brsf_ag_hf_indicators,
&hf_brsf_ag_esco_s4_t2_settings_support,
&hf_brsf_ag_reserved,
NULL
};
proto_tree_add_boolean(ptree, hf_brsf_ag_three_way_calling, tvb, offset, parameter_length, value); pitem = proto_tree_add_bitmask_value_with_flags(tree, tvb, offset, hf_brsf_ag, ett_bthfp_brsf_ag, ag, value, BMT_NO_APPEND);
proto_tree_add_boolean(ptree, hf_brsf_ag_ec_nr_function, tvb, offset, parameter_length, value);
proto_tree_add_boolean(ptree, hf_brsf_ag_voice_recognition_function, tvb, offset, parameter_length, value);
proto_tree_add_boolean(ptree, hf_brsf_ag_inband_ring_tone, tvb, offset, parameter_length, value);
proto_tree_add_boolean(ptree, hf_brsf_ag_attach_number_to_voice_tag, tvb, offset, parameter_length, value);
proto_tree_add_boolean(ptree, hf_brsf_ag_ability_to_reject_a_call, tvb, offset, parameter_length, value);
proto_tree_add_boolean(ptree, hf_brsf_ag_enhanced_call_status, tvb, offset, parameter_length, value);
proto_tree_add_boolean(ptree, hf_brsf_ag_enhanced_call_control, tvb, offset, parameter_length, value);
proto_tree_add_boolean(ptree, hf_brsf_ag_extended_error_result_codes, tvb, offset, parameter_length, value);
proto_tree_add_boolean(ptree, hf_brsf_ag_codec_negotiation, tvb, offset, parameter_length, value);
proto_tree_add_boolean(ptree, hf_brsf_ag_hf_indicators, tvb, offset, parameter_length, value);
proto_tree_add_boolean(ptree, hf_brsf_ag_esco_s4_t2_settings_support, tvb, offset, parameter_length, value);
pitem = proto_tree_add_uint(ptree, hf_brsf_ag_reserved, tvb, offset, parameter_length, value);
if (value >> 10) { if (value >> 10) {
expert_add_info(pinfo, pitem, &ei_brfs_ag_reserved_bits); expert_add_info(pinfo, pitem, &ei_brfs_ag_reserved_bits);

8
epan/dissectors/packet-catapult-dct2000.c
View File

@ -1259,16 +1259,16 @@ static void dissect_pdcp_lte(tvbuff_t *tvb, gint offset,
/* CNF follows MUI in AM */ /* CNF follows MUI in AM */
if ((opcode == RLC_AM_DATA_REQ) || (opcode == RLC_AM_DATA_IND)) { if ((opcode == RLC_AM_DATA_REQ) || (opcode == RLC_AM_DATA_IND)) {
proto_tree_add_boolean(tree, hf_catapult_dct2000_lte_rlc_cnf, proto_tree_add_item(tree, hf_catapult_dct2000_lte_rlc_cnf,
tvb, offset, 1, tvb_get_guint8(tvb, offset)); tvb, offset, 1, ENC_NA);
offset++; offset++;
} }
} }
else if (tag == 0x45) { else if (tag == 0x45) {
/* Discard Req */ /* Discard Req */
offset++; offset++;
proto_tree_add_boolean(tree, hf_catapult_dct2000_lte_rlc_discard_req, proto_tree_add_item(tree, hf_catapult_dct2000_lte_rlc_discard_req,
tvb, offset, 1, tvb_get_guint8(tvb, offset)); tvb, offset, 1, ENC_NA);
offset++; offset++;
} }

479
epan/dissectors/packet-dcerpc-netlogon.c
View File

@ -612,8 +612,13 @@ netlogon_dissect_EXTRA_FLAGS(tvbuff_t *tvb, int offset,
packet_info *pinfo, proto_tree *parent_tree, dcerpc_info *di, guint8 *drep) packet_info *pinfo, proto_tree *parent_tree, dcerpc_info *di, guint8 *drep)
{ {
guint32 mask; guint32 mask;
proto_item *item = NULL; static const int * extraflags[] = {
proto_tree *tree = NULL; &hf_netlogon_extra_flags_root_forest,
&hf_netlogon_trust_flags_dc_firsthop,
&hf_netlogon_trust_flags_rodc_to_dc,
&hf_netlogon_trust_flags_rodc_ntlm,
NULL
};
if(di->conformant_run){ if(di->conformant_run){
/*just a run to handle conformant arrays, nothing to dissect */ /*just a run to handle conformant arrays, nothing to dissect */
@ -621,23 +626,9 @@ netlogon_dissect_EXTRA_FLAGS(tvbuff_t *tvb, int offset,
} }
offset=dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, offset=dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep,
hf_netlogon_extraflags, &mask); -1, &mask);
if(parent_tree){
item = proto_tree_add_uint(parent_tree, hf_netlogon_extraflags,
tvb, offset-4, 4, mask);
tree = proto_item_add_subtree(item, ett_trust_flags);
}
proto_tree_add_boolean(tree, hf_netlogon_extra_flags_root_forest,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_trust_flags_dc_firsthop,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_trust_flags_rodc_to_dc,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_trust_flags_rodc_ntlm,
tvb, offset-4, 4, mask);
proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset-4, hf_netlogon_extraflags, ett_trust_flags, extraflags, mask, BMT_NO_APPEND);
return offset; return offset;
} }
static int static int
@ -702,8 +693,26 @@ netlogon_dissect_USER_ACCOUNT_CONTROL(tvbuff_t *tvb, int offset,
packet_info *pinfo, proto_tree *parent_tree, dcerpc_info *di, guint8 *drep) packet_info *pinfo, proto_tree *parent_tree, dcerpc_info *di, guint8 *drep)
{ {
guint32 mask; guint32 mask;
proto_item *item = NULL; static const int * uac[] = {
proto_tree *tree = NULL; &hf_netlogon_user_account_control_dont_require_preauth,
&hf_netlogon_user_account_control_use_des_key_only,
&hf_netlogon_user_account_control_not_delegated,
&hf_netlogon_user_account_control_trusted_for_delegation,
&hf_netlogon_user_account_control_smartcard_required,
&hf_netlogon_user_account_control_encrypted_text_password_allowed,
&hf_netlogon_user_account_control_account_auto_locked,
&hf_netlogon_user_account_control_dont_expire_password,
&hf_netlogon_user_account_control_server_trust_account,
&hf_netlogon_user_account_control_workstation_trust_account,
&hf_netlogon_user_account_control_interdomain_trust_account,
&hf_netlogon_user_account_control_mns_logon_account,
&hf_netlogon_user_account_control_normal_account,
&hf_netlogon_user_account_control_temp_duplicate_account,
&hf_netlogon_user_account_control_password_not_required,
&hf_netlogon_user_account_control_home_directory_required,
&hf_netlogon_user_account_control_account_disabled,
NULL
};
if(di->conformant_run){ if(di->conformant_run){
/*just a run to handle conformant arrays, nothing to dissect */ /*just a run to handle conformant arrays, nothing to dissect */
@ -711,48 +720,10 @@ netlogon_dissect_USER_ACCOUNT_CONTROL(tvbuff_t *tvb, int offset,
} }
offset=dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, offset=dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep,
hf_netlogon_user_account_control, &mask); -1, &mask);
if(parent_tree){ proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset-4, hf_netlogon_user_account_control, ett_user_account_control, uac, mask, BMT_NO_APPEND);
item = proto_tree_add_uint(parent_tree, hf_netlogon_user_account_control,
tvb, offset-4, 4, mask);
tree = proto_item_add_subtree(item, ett_user_account_control);
}
proto_tree_add_boolean(tree, hf_netlogon_user_account_control_dont_require_preauth,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_user_account_control_use_des_key_only,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_user_account_control_not_delegated,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_user_account_control_trusted_for_delegation,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_user_account_control_smartcard_required,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_user_account_control_encrypted_text_password_allowed,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_user_account_control_account_auto_locked,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_user_account_control_dont_expire_password,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_user_account_control_server_trust_account,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_user_account_control_workstation_trust_account,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_user_account_control_interdomain_trust_account,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_user_account_control_mns_logon_account,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_user_account_control_normal_account,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_user_account_control_temp_duplicate_account,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_user_account_control_password_not_required,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_user_account_control_home_directory_required,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_user_account_control_account_disabled,
tvb, offset-4, 4, mask);
return offset; return offset;
} }
@ -1408,8 +1379,12 @@ netlogon_dissect_GROUP_MEMBERSHIP_ATTRIBUTES(tvbuff_t *tvb, int offset,
packet_info *pinfo, proto_tree *parent_tree, dcerpc_info *di, guint8 *drep) packet_info *pinfo, proto_tree *parent_tree, dcerpc_info *di, guint8 *drep)
{ {
guint32 mask; guint32 mask;
proto_item *item = NULL; static const int * attr[] = {
proto_tree *tree = NULL; &hf_netlogon_group_attrs_enabled,
&hf_netlogon_group_attrs_enabled_by_default,
&hf_netlogon_group_attrs_mandatory,
NULL
};
if(di->conformant_run){ if(di->conformant_run){
/*just a run to handle conformant arrays, nothing to dissect */ /*just a run to handle conformant arrays, nothing to dissect */
@ -1417,21 +1392,9 @@ netlogon_dissect_GROUP_MEMBERSHIP_ATTRIBUTES(tvbuff_t *tvb, int offset,
} }
offset=dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, offset=dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep,
hf_netlogon_attrs, &mask); -1, &mask);
if(parent_tree){
item = proto_tree_add_uint(parent_tree, hf_netlogon_attrs,
tvb, offset-4, 4, mask);
tree = proto_item_add_subtree(item, ett_group_attrs);
}
proto_tree_add_boolean(tree, hf_netlogon_group_attrs_enabled,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_group_attrs_enabled_by_default,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_group_attrs_mandatory,
tvb, offset-4, 4, mask);
proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset-4, hf_netlogon_attrs, ett_group_attrs, attr, mask, BMT_NO_APPEND);
return offset; return offset;
} }
@ -1511,8 +1474,11 @@ netlogon_dissect_USER_FLAGS(tvbuff_t *tvb, int offset,
packet_info *pinfo, proto_tree *parent_tree, dcerpc_info *di, guint8 *drep) packet_info *pinfo, proto_tree *parent_tree, dcerpc_info *di, guint8 *drep)
{ {
guint32 mask; guint32 mask;
proto_item *item = NULL; static const int * flags[] = {
proto_tree *tree = NULL; &hf_netlogon_user_flags_resource_groups,
&hf_netlogon_user_flags_extra_sids,
NULL
};
if(di->conformant_run){ if(di->conformant_run){
/*just a run to handle conformant arrays, nothing to dissect */ /*just a run to handle conformant arrays, nothing to dissect */
@ -1520,19 +1486,9 @@ netlogon_dissect_USER_FLAGS(tvbuff_t *tvb, int offset,
} }
offset=dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, offset=dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep,
hf_netlogon_user_flags, &mask); -1, &mask);
if(parent_tree){
item = proto_tree_add_uint(parent_tree, hf_netlogon_user_flags,
tvb, offset-4, 4, mask);
tree = proto_item_add_subtree(item, ett_user_flags);
}
proto_tree_add_boolean(tree, hf_netlogon_user_flags_resource_groups,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_user_flags_extra_sids,
tvb, offset-4, 4, mask);
proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset-4, hf_netlogon_user_flags, ett_user_flags, flags, mask, BMT_NO_APPEND);
return offset; return offset;
} }
@ -5143,8 +5099,15 @@ netlogon_dissect_DOMAIN_TRUST_FLAGS(tvbuff_t *tvb, int offset,
packet_info *pinfo, proto_tree *parent_tree, dcerpc_info *di, guint8 *drep) packet_info *pinfo, proto_tree *parent_tree, dcerpc_info *di, guint8 *drep)
{ {
guint32 mask; guint32 mask;
proto_item *item = NULL; static const int * flags[] = {
proto_tree *tree = NULL; &hf_netlogon_trust_flags_inbound,
&hf_netlogon_trust_flags_native_mode,
&hf_netlogon_trust_flags_primary,
&hf_netlogon_trust_flags_tree_root,
&hf_netlogon_trust_flags_outbound,
&hf_netlogon_trust_flags_in_forest,
NULL
};
if(di->conformant_run){ if(di->conformant_run){
/*just a run to handle conformant arrays, nothing to dissect */ /*just a run to handle conformant arrays, nothing to dissect */
@ -5152,27 +5115,9 @@ netlogon_dissect_DOMAIN_TRUST_FLAGS(tvbuff_t *tvb, int offset,
} }
offset=dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, offset=dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep,
hf_netlogon_trust_flags, &mask); -1, &mask);
if(parent_tree){
item = proto_tree_add_uint(parent_tree, hf_netlogon_trust_flags,
tvb, offset-4, 4, mask);
tree = proto_item_add_subtree(item, ett_trust_flags);
}
proto_tree_add_boolean(tree, hf_netlogon_trust_flags_inbound,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_trust_flags_native_mode,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_trust_flags_primary,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_trust_flags_tree_root,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_trust_flags_outbound,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_trust_flags_in_forest,
tvb, offset-4, 4, mask);
proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset-4, hf_netlogon_trust_flags, ett_trust_flags, flags, mask, BMT_NO_APPEND);
return offset; return offset;
} }
@ -5212,8 +5157,16 @@ netlogon_dissect_DOMAIN_TRUST_ATTRIBS(tvbuff_t *tvb, int offset,
packet_info *pinfo, proto_tree *parent_tree, dcerpc_info *di, guint8 *drep) packet_info *pinfo, proto_tree *parent_tree, dcerpc_info *di, guint8 *drep)
{ {
guint32 mask; guint32 mask;
proto_item *item = NULL; static const int * attr[] = {
proto_tree *tree = NULL; &hf_netlogon_trust_attribs_treat_as_external,
&hf_netlogon_trust_attribs_within_forest,
&hf_netlogon_trust_attribs_cross_organization,
&hf_netlogon_trust_attribs_forest_transitive,
&hf_netlogon_trust_attribs_quarantined_domain,
&hf_netlogon_trust_attribs_uplevel_only,
&hf_netlogon_trust_attribs_non_transitive,
NULL
};
if(di->conformant_run){ if(di->conformant_run){
/*just a run to handle conformant arrays, nothing to dissect */ /*just a run to handle conformant arrays, nothing to dissect */
@ -5221,30 +5174,9 @@ netlogon_dissect_DOMAIN_TRUST_ATTRIBS(tvbuff_t *tvb, int offset,
} }
offset = dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, offset = dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep,
hf_netlogon_trust_attribs, &mask); -1, &mask);
if(parent_tree){
item = proto_tree_add_uint(parent_tree, hf_netlogon_trust_attribs,
tvb, offset-4, 4, mask);
tree = proto_item_add_subtree(item, ett_trust_attribs);
}
proto_tree_add_boolean(tree, hf_netlogon_trust_attribs_treat_as_external,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_trust_attribs_within_forest,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_trust_attribs_cross_organization,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_trust_attribs_forest_transitive,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_trust_attribs_quarantined_domain,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_trust_attribs_uplevel_only,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_trust_attribs_non_transitive,
tvb, offset-4, 4, mask);
proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset-4, hf_netlogon_trust_attribs, ett_trust_attribs, attr, mask, BMT_NO_APPEND);
return offset; return offset;
} }
@ -5340,58 +5272,35 @@ netlogon_dissect_GET_DCNAME_REQUEST_FLAGS(tvbuff_t *tvb, int offset,
packet_info *pinfo, proto_tree *parent_tree, dcerpc_info *di, guint8 *drep) packet_info *pinfo, proto_tree *parent_tree, dcerpc_info *di, guint8 *drep)
{ {
guint32 mask; guint32 mask;
proto_item *item = NULL; static const int * flags[] = {
proto_tree *tree = NULL; &hf_netlogon_get_dcname_request_flags_return_flat_name,
&hf_netlogon_get_dcname_request_flags_return_dns_name,
&hf_netlogon_get_dcname_request_flags_is_flat_name,
&hf_netlogon_get_dcname_request_flags_is_dns_name,
&hf_netlogon_get_dcname_request_flags_only_ldap_needed,
&hf_netlogon_get_dcname_request_flags_avoid_self,
&hf_netlogon_get_dcname_request_flags_good_timeserv_preferred,
&hf_netlogon_get_dcname_request_flags_writable_required,
&hf_netlogon_get_dcname_request_flags_timeserv_required,
&hf_netlogon_get_dcname_request_flags_kdc_required,
&hf_netlogon_get_dcname_request_flags_ip_required,
&hf_netlogon_get_dcname_request_flags_background_only,
&hf_netlogon_get_dcname_request_flags_pdc_required,
&hf_netlogon_get_dcname_request_flags_gc_server_required,
&hf_netlogon_get_dcname_request_flags_directory_service_preferred,
&hf_netlogon_get_dcname_request_flags_directory_service_required,
&hf_netlogon_get_dcname_request_flags_force_rediscovery,
NULL
};
if(di->conformant_run){ if(di->conformant_run){
/*just a run to handle conformant arrays, nothing to dissect */ /*just a run to handle conformant arrays, nothing to dissect */
return offset; return offset;
} }
offset=dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, offset=dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, -1, &mask);
hf_netlogon_get_dcname_request_flags, &mask);
if(parent_tree){
item = proto_tree_add_uint(parent_tree, hf_netlogon_get_dcname_request_flags,
tvb, offset-4, 4, mask);
tree = proto_item_add_subtree(item, ett_get_dcname_request_flags);
}
proto_tree_add_boolean(tree, hf_netlogon_get_dcname_request_flags_return_flat_name,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_get_dcname_request_flags_return_dns_name,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_get_dcname_request_flags_is_flat_name,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_get_dcname_request_flags_is_dns_name,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_get_dcname_request_flags_only_ldap_needed,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_get_dcname_request_flags_avoid_self,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_get_dcname_request_flags_good_timeserv_preferred,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_get_dcname_request_flags_writable_required,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_get_dcname_request_flags_timeserv_required,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_get_dcname_request_flags_kdc_required,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_get_dcname_request_flags_ip_required,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_get_dcname_request_flags_background_only,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_get_dcname_request_flags_pdc_required,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_get_dcname_request_flags_gc_server_required,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_get_dcname_request_flags_directory_service_preferred,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_get_dcname_request_flags_directory_service_required,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_get_dcname_request_flags_force_rediscovery,
tvb, offset-4, 4, mask);
proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset-4, hf_netlogon_get_dcname_request_flags, ett_get_dcname_request_flags, flags, mask, BMT_NO_APPEND);
return offset; return offset;
} }
@ -5468,49 +5377,34 @@ netlogon_dissect_DC_FLAGS(tvbuff_t *tvb, int offset,
packet_info *pinfo, proto_tree *parent_tree, dcerpc_info *di, guint8 *drep) packet_info *pinfo, proto_tree *parent_tree, dcerpc_info *di, guint8 *drep)
{ {
guint32 mask; guint32 mask;
proto_item *item = NULL; proto_item *item;
proto_tree *tree = NULL; static const int * flags[] = {
&hf_netlogon_dc_flags_dns_forest_flag,
&hf_netlogon_dc_flags_dns_domain_flag,
&hf_netlogon_dc_flags_dns_controller_flag,
&hf_netlogon_dc_flags_ndnc_flag,
&hf_netlogon_dc_flags_good_timeserv_flag,
&hf_netlogon_dc_flags_writable_flag,
&hf_netlogon_dc_flags_closest_flag,
&hf_netlogon_dc_flags_timeserv_flag,
&hf_netlogon_dc_flags_kdc_flag,
&hf_netlogon_dc_flags_ds_flag,
&hf_netlogon_dc_flags_ldap_flag,
&hf_netlogon_dc_flags_gc_flag,
&hf_netlogon_dc_flags_pdc_flag,
NULL
};
if(di->conformant_run){ if(di->conformant_run){
/*just a run to handle conformant arrays, nothing to dissect */ /*just a run to handle conformant arrays, nothing to dissect */
return offset; return offset;
} }
offset=dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, offset=dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, -1, &mask);
hf_netlogon_dc_flags, &mask);
if(parent_tree){ item = proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset-4, hf_netlogon_dc_flags, ett_dc_flags, flags, mask, BMT_NO_APPEND);
item = proto_tree_add_uint_format_value(parent_tree, hf_netlogon_dc_flags, if (mask==0x0000ffff)
tvb, offset-4, 4, mask, "0x%08x%s", mask, (mask==0x0000ffff)?" PING (mask==0x0000ffff)":""); proto_item_append_text(item, " PING (mask==0x0000ffff)");
tree = proto_item_add_subtree(item, ett_dc_flags);
}
proto_tree_add_boolean(tree, hf_netlogon_dc_flags_dns_forest_flag,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_dc_flags_dns_domain_flag,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_dc_flags_dns_controller_flag,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_dc_flags_ndnc_flag,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_dc_flags_good_timeserv_flag,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_dc_flags_writable_flag,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_dc_flags_closest_flag,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_dc_flags_timeserv_flag,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_dc_flags_kdc_flag,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_dc_flags_ds_flag,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_dc_flags_ldap_flag,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_dc_flags_gc_flag,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_netlogon_dc_flags_pdc_flag,
tvb, offset-4, 4, mask);
return offset; return offset;
} }
@ -6537,115 +6431,48 @@ netlogon_dissect_netrlogoncomputeclientdigest_reply(tvbuff_t *tvb, int offset,
} }
static int netlogon_dissect_neg_options(tvbuff_t *tvb,proto_tree *tree,guint32 flags,int offset) static int netlogon_dissect_neg_options(tvbuff_t *tvb,proto_tree *tree,guint32 flags,int offset)
{ {
if (tree) { static const int * hf_flags[] = {
proto_tree *negotiate_flags_tree = NULL; #if 0
proto_item *tf = NULL; &hf_netlogon_neg_flags_80000000,
tf = proto_tree_add_uint (tree, #endif
hf_netlogon_neg_flags, &hf_netlogon_neg_flags_40000000,
tvb, offset, 4,flags); &hf_netlogon_neg_flags_20000000,
negotiate_flags_tree = proto_item_add_subtree (tf,ett_authenticate_flags); #if 0
&hf_netlogon_neg_flags_10000000,
&hf_netlogon_neg_flags_8000000,
&hf_netlogon_neg_flags_4000000,
&hf_netlogon_neg_flags_2000000,
&hf_netlogon_neg_flags_800000,
#endif
&hf_netlogon_neg_flags_1000000,
&hf_netlogon_neg_flags_400000,
&hf_netlogon_neg_flags_200000,
&hf_netlogon_neg_flags_100000,
&hf_netlogon_neg_flags_80000,
&hf_netlogon_neg_flags_40000,
&hf_netlogon_neg_flags_20000,
&hf_netlogon_neg_flags_10000,
&hf_netlogon_neg_flags_8000,
&hf_netlogon_neg_flags_4000,
&hf_netlogon_neg_flags_2000,
&hf_netlogon_neg_flags_1000,
&hf_netlogon_neg_flags_800,
&hf_netlogon_neg_flags_400,
&hf_netlogon_neg_flags_200,
&hf_netlogon_neg_flags_100,
&hf_netlogon_neg_flags_80,
&hf_netlogon_neg_flags_40,
&hf_netlogon_neg_flags_20,
&hf_netlogon_neg_flags_10,
&hf_netlogon_neg_flags_8,
&hf_netlogon_neg_flags_4,
&hf_netlogon_neg_flags_2,
&hf_netlogon_neg_flags_1,
NULL
};
proto_tree_add_bitmask_value_with_flags(tree, tvb, offset, hf_netlogon_neg_flags, ett_authenticate_flags, hf_flags, flags, BMT_NO_APPEND);
#if 0
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_80000000,
tvb, offset, 4, flags);
#endif
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_40000000,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_20000000,
tvb, offset, 4, flags);
#if 0
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_10000000,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_8000000,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_4000000,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_2000000,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_800000,
tvb, offset, 4, flags);
#endif
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_1000000,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_400000,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_200000,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_100000,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_80000,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_40000,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_20000,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_10000,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_8000,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_4000,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_2000,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_1000,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_800,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_400,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_200,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_100,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_80,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_40,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_20,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_10,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_8,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_4,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_2,
tvb, offset, 4, flags);
proto_tree_add_boolean (negotiate_flags_tree,
hf_netlogon_neg_flags_1,
tvb, offset, 4, flags);
}
return 0; return 0;
} }

49
epan/dissectors/packet-dcerpc-nt.c
View File

@ -1594,40 +1594,25 @@ dissect_ndr_nt_acct_ctrl(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *parent_tree, dcerpc_info *di, guint8 *drep) proto_tree *parent_tree, dcerpc_info *di, guint8 *drep)
{ {
guint32 mask; guint32 mask;
proto_item *item = NULL; static const int * flags[] = {
proto_tree *tree = NULL; &hf_nt_acb_autolock,
&hf_nt_acb_pwnoexp,
&hf_nt_acb_svrtrust,
&hf_nt_acb_wstrust,
&hf_nt_acb_domtrust,
&hf_nt_acb_mns,
&hf_nt_acb_normal,
&hf_nt_acb_tempdup,
&hf_nt_acb_pwnotreq,
&hf_nt_acb_homedirreq,
&hf_nt_acb_disabled,
NULL
};
offset=dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, offset=dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, -1, &mask);
hf_nt_acct_ctrl, &mask);
if(parent_tree){ proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset-4, hf_nt_acct_ctrl,
item = proto_tree_add_uint(parent_tree, hf_nt_acct_ctrl, ett_nt_acct_ctrl, flags, mask, BMT_NO_APPEND);
tvb, offset-4, 4, mask);
tree = proto_item_add_subtree(item, ett_nt_acct_ctrl);
}
proto_tree_add_boolean(tree, hf_nt_acb_autolock,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_nt_acb_pwnoexp,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_nt_acb_svrtrust,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_nt_acb_wstrust,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_nt_acb_domtrust,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_nt_acb_mns,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_nt_acb_normal,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_nt_acb_tempdup,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_nt_acb_pwnotreq,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_nt_acb_homedirreq,
tvb, offset-4, 4, mask);
proto_tree_add_boolean(tree, hf_nt_acb_disabled,
tvb, offset-4, 4, mask);
return offset; return offset;
} }

506
epan/dissectors/packet-dcerpc-spoolss.c
View File

@ -1378,134 +1378,49 @@ static int
dissect_DEVMODE_fields(tvbuff_t *tvb, gint offset, packet_info *pinfo, dissect_DEVMODE_fields(tvbuff_t *tvb, gint offset, packet_info *pinfo,
proto_tree *tree, dcerpc_info *di, guint8 *drep _U_, guint32 *pdata) proto_tree *tree, dcerpc_info *di, guint8 *drep _U_, guint32 *pdata)
{ {
proto_item *item;
proto_tree *subtree;
guint32 fields; guint32 fields;
proto_item *hidden_item; proto_item *hidden_item;
static const int * hf_fields[] = {
&hf_devmode_fields_orientation,
&hf_devmode_fields_papersize,
&hf_devmode_fields_paperlength,
&hf_devmode_fields_paperwidth,
&hf_devmode_fields_scale,
&hf_devmode_fields_position,
&hf_devmode_fields_nup,
&hf_devmode_fields_copies,
&hf_devmode_fields_defaultsource,
&hf_devmode_fields_printquality,
&hf_devmode_fields_color,
&hf_devmode_fields_duplex,
&hf_devmode_fields_yresolution,
&hf_devmode_fields_ttoption,
&hf_devmode_fields_collate,
&hf_devmode_fields_formname,
&hf_devmode_fields_logpixels,
&hf_devmode_fields_bitsperpel,
&hf_devmode_fields_pelswidth,
&hf_devmode_fields_pelsheight,
&hf_devmode_fields_displayflags,
&hf_devmode_fields_displayfrequency,
&hf_devmode_fields_icmmethod,
&hf_devmode_fields_icmintent,
&hf_devmode_fields_mediatype,
&hf_devmode_fields_dithertype,
&hf_devmode_fields_panningwidth,
&hf_devmode_fields_panningheight,
NULL
};
hidden_item = proto_tree_add_uint( hidden_item = proto_tree_add_uint(
tree, hf_devmode, tvb, offset, 0, 1); tree, hf_devmode, tvb, offset, 0, 1);
PROTO_ITEM_SET_HIDDEN(hidden_item); PROTO_ITEM_SET_HIDDEN(hidden_item);
offset = dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, offset = dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, -1, &fields);
hf_devmode_fields, &fields);
item = proto_tree_add_text(tree, tvb, offset - 4, 4, proto_tree_add_bitmask_value_with_flags(tree, tvb, offset - 4, hf_devmode_fields,
"Fields: 0x%08x", fields); ett_DEVMODE_fields, hf_fields, fields, BMT_NO_APPEND);
subtree = proto_item_add_subtree(item, ett_DEVMODE_fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_orientation,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_papersize,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_paperlength,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_paperwidth,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_scale,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_position,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_nup,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_copies,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_defaultsource,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_printquality,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_color,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_duplex,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_yresolution,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_ttoption,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_collate,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_formname,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_logpixels,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_bitsperpel,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_pelswidth,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_pelsheight,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_displayflags,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_displayfrequency,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_icmmethod,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_icmintent,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_mediatype,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_dithertype,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_panningwidth,
tvb, offset - 4, 4, fields);
proto_tree_add_boolean(
subtree, hf_devmode_fields_panningheight,
tvb, offset - 4, 4, fields);
if (pdata) if (pdata)
*pdata = fields; *pdata = fields;
@ -1597,9 +1512,9 @@ dissect_DEVMODE(tvbuff_t *tvb, int offset, packet_info *pinfo,
subtree, hf_devmode_print_quality, tvb, subtree, hf_devmode_print_quality, tvb,
offset - 2, 2, DREP_ENC_INTEGER(drep)); offset - 2, 2, DREP_ENC_INTEGER(drep));
else else
proto_tree_add_text( proto_tree_add_uint_format_value(
subtree, tvb, offset - 4, 4, subtree, hf_devmode_print_quality, tvb, offset - 4, 4,
"Print Quality: %d dpi", print_quality); print_quality, "%d dpi", print_quality);
offset = dissect_ndr_uint16( offset = dissect_ndr_uint16(
tvb, offset, pinfo, subtree, di, drep, tvb, offset, pinfo, subtree, di, drep,
@ -2071,51 +1986,26 @@ static int
dissect_job_status(tvbuff_t *tvb, int offset, packet_info *pinfo, dissect_job_status(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, dcerpc_info *di, guint8 *drep) proto_tree *tree, dcerpc_info *di, guint8 *drep)
{ {
proto_item *item;
proto_tree *subtree;
guint32 status; guint32 status;
static const int * hf_status[] = {
&hf_job_status_user_intervention,
&hf_job_status_blocked,
&hf_job_status_deleted,
&hf_job_status_printed,
&hf_job_status_paperout,
&hf_job_status_offline,
&hf_job_status_printing,
&hf_job_status_spooling,
&hf_job_status_deleting,
&hf_job_status_error,
&hf_job_status_paused,
NULL
};
offset = dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, offset = dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, -1, &status);
hf_job_status, &status);
item = proto_tree_add_text(tree, tvb, offset - 4, 4, proto_tree_add_bitmask_value_with_flags(tree, tvb, offset - 4, hf_job_status,
"Status: 0x%08x", status); ett_job_status, hf_status, status, BMT_NO_APPEND);
subtree = proto_item_add_subtree(item, ett_job_status);
proto_tree_add_boolean(
subtree, hf_job_status_user_intervention, tvb, offset - 4, 4,
status);
proto_tree_add_boolean(
subtree, hf_job_status_blocked, tvb, offset - 4, 4, status);
proto_tree_add_boolean(
subtree, hf_job_status_deleted, tvb, offset - 4, 4, status);
proto_tree_add_boolean(
subtree, hf_job_status_printed, tvb, offset - 4, 4, status);
proto_tree_add_boolean(
subtree, hf_job_status_paperout, tvb, offset - 4, 4, status);
proto_tree_add_boolean(
subtree, hf_job_status_offline, tvb, offset - 4, 4, status);
proto_tree_add_boolean(
subtree, hf_job_status_printing, tvb, offset - 4, 4, status);
proto_tree_add_boolean(
subtree, hf_job_status_spooling, tvb, offset - 4, 4, status);
proto_tree_add_boolean(
subtree, hf_job_status_deleting, tvb, offset - 4, 4, status);
proto_tree_add_boolean(
subtree, hf_job_status_error, tvb, offset - 4, 4, status);
proto_tree_add_boolean(
subtree, hf_job_status_paused, tvb, offset - 4, 4, status);
return offset; return offset;
} }
@ -2214,73 +2104,29 @@ static int
dissect_printer_attributes(tvbuff_t *tvb, int offset, packet_info *pinfo, dissect_printer_attributes(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, dcerpc_info *di, guint8 *drep) proto_tree *tree, dcerpc_info *di, guint8 *drep)
{ {
proto_item *item;
proto_tree *subtree;
guint32 attributes; guint32 attributes;
static const int * hf_attributes[] = {
&hf_printer_attributes_published,
&hf_printer_attributes_raw_only,
&hf_printer_attributes_enable_bidi,
&hf_printer_attributes_work_offline,
&hf_printer_attributes_do_complete_first,
&hf_printer_attributes_keep_printed_jobs,
&hf_printer_attributes_enable_devq,
&hf_printer_attributes_local,
&hf_printer_attributes_hidden,
&hf_printer_attributes_network,
&hf_printer_attributes_shared,
&hf_printer_attributes_default,
&hf_printer_attributes_direct,
&hf_printer_attributes_queued,
NULL
};
offset = dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, offset = dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, -1, &attributes);
hf_printer_attributes, &attributes);
item = proto_tree_add_text(tree, tvb, offset - 4, 4, proto_tree_add_bitmask_value_with_flags(tree, tvb, offset - 4, hf_printer_attributes,
"Attributes: 0x%08x", attributes); ett_printer_attributes, hf_attributes, attributes, BMT_NO_APPEND);
subtree = proto_item_add_subtree(item, ett_printer_attributes);
proto_tree_add_boolean(
subtree, hf_printer_attributes_published,
tvb, offset - 4, 4, attributes);
proto_tree_add_boolean(
subtree, hf_printer_attributes_raw_only,
tvb, offset - 4, 4, attributes);
proto_tree_add_boolean(
subtree, hf_printer_attributes_enable_bidi,
tvb, offset - 4, 4, attributes);
proto_tree_add_boolean(
subtree, hf_printer_attributes_work_offline,
tvb, offset - 4, 4, attributes);
proto_tree_add_boolean(
subtree, hf_printer_attributes_do_complete_first,
tvb, offset - 4, 4, attributes);
proto_tree_add_boolean(
subtree, hf_printer_attributes_keep_printed_jobs,
tvb, offset - 4, 4, attributes);
proto_tree_add_boolean(
subtree, hf_printer_attributes_enable_devq,
tvb, offset - 4, 4, attributes);
proto_tree_add_boolean(
subtree, hf_printer_attributes_local,
tvb, offset - 4, 4, attributes);
proto_tree_add_boolean(
subtree, hf_printer_attributes_hidden,
tvb, offset - 4, 4, attributes);
proto_tree_add_boolean(
subtree, hf_printer_attributes_network,
tvb, offset - 4, 4, attributes);
proto_tree_add_boolean(
subtree, hf_printer_attributes_shared,
tvb, offset - 4, 4, attributes);
proto_tree_add_boolean(
subtree, hf_printer_attributes_default,
tvb, offset - 4, 4, attributes);
proto_tree_add_boolean(
subtree, hf_printer_attributes_direct,
tvb, offset - 4, 4, attributes);
proto_tree_add_boolean(
subtree, hf_printer_attributes_queued,
tvb, offset - 4, 4, attributes);
return offset; return offset;
} }
@ -2882,22 +2728,16 @@ static int
dissect_notify_options_flags(tvbuff_t *tvb, int offset, packet_info *pinfo, dissect_notify_options_flags(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, dcerpc_info *di, guint8 *drep) proto_tree *tree, dcerpc_info *di, guint8 *drep)
{ {
proto_item *item;
proto_tree *subtree;
guint32 flags; guint32 flags;
static const int * hf_flags[] = {
&hf_notify_options_flags_refresh,
NULL
};
offset = dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, offset = dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, -1, &flags);
hf_notify_options_flags,
&flags);
item = proto_tree_add_text(tree, tvb, offset - 4, 4, proto_tree_add_bitmask_value_with_flags(tree, tvb, offset - 4, hf_notify_options_flags,
"Flags: 0x%08x", flags); ett_notify_options_flags, hf_flags, flags, BMT_NO_APPEND);
subtree = proto_item_add_subtree(item, ett_notify_options_flags);
proto_tree_add_boolean(
subtree, hf_notify_options_flags_refresh,
tvb, offset, 4, flags);
return offset; return offset;
} }
@ -3068,8 +2908,29 @@ SpoolssRFFPCNEX_q(tvbuff_t *tvb, int offset,
dcerpc_info *di, guint8 *drep _U_) dcerpc_info *di, guint8 *drep _U_)
{ {
guint32 flags; guint32 flags;
proto_item *flags_item; static const int * hf_flags[] = {
proto_tree *flags_subtree; &hf_rffpcnex_flags_timeout,
&hf_rffpcnex_flags_delete_driver,
&hf_rffpcnex_flags_set_driver,
&hf_rffpcnex_flags_add_driver,
&hf_rffpcnex_flags_delete_print_processor,
&hf_rffpcnex_flags_add_print_processor,
&hf_rffpcnex_flags_delete_port,
&hf_rffpcnex_flags_configure_port,
&hf_rffpcnex_flags_add_port,
&hf_rffpcnex_flags_delete_form,
&hf_rffpcnex_flags_set_form,
&hf_rffpcnex_flags_add_form,
&hf_rffpcnex_flags_write_job,
&hf_rffpcnex_flags_delete_job,
&hf_rffpcnex_flags_set_job,
&hf_rffpcnex_flags_add_job,
&hf_rffpcnex_flags_failed_printer_connection,
&hf_rffpcnex_flags_delete_printer,
&hf_rffpcnex_flags_set_printer,
&hf_rffpcnex_flags_add_printer,
NULL
};
/* Parse packet */ /* Parse packet */
@ -3077,110 +2938,10 @@ SpoolssRFFPCNEX_q(tvbuff_t *tvb, int offset,
tvb, offset, pinfo, tree, di, drep, hf_hnd, NULL, NULL, tvb, offset, pinfo, tree, di, drep, hf_hnd, NULL, NULL,
FALSE, FALSE); FALSE, FALSE);
offset = dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, offset = dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, -1, &flags);
hf_rffpcnex_flags, &flags);
flags_item = proto_tree_add_text(tree, tvb, offset - 4, 4, proto_tree_add_bitmask_value(tree, tvb, offset - 4, hf_rffpcnex_flags,
"Flags: 0x%08x", flags); ett_rffpcnex_flags, hf_flags, flags);
flags_subtree = proto_item_add_subtree(flags_item, ett_rffpcnex_flags);
proto_tree_add_boolean(
flags_subtree, hf_rffpcnex_flags_timeout, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree, hf_rffpcnex_flags_delete_driver, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree, hf_rffpcnex_flags_set_driver, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree, hf_rffpcnex_flags_add_driver, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree,
hf_rffpcnex_flags_delete_print_processor, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree, hf_rffpcnex_flags_add_print_processor,
tvb, offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree, hf_rffpcnex_flags_delete_port, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree, hf_rffpcnex_flags_configure_port, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree, hf_rffpcnex_flags_add_port, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree, hf_rffpcnex_flags_delete_form, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree, hf_rffpcnex_flags_set_form, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree, hf_rffpcnex_flags_add_form, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree, hf_rffpcnex_flags_write_job, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree, hf_rffpcnex_flags_delete_job, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree, hf_rffpcnex_flags_set_job, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree, hf_rffpcnex_flags_add_job, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree,
hf_rffpcnex_flags_failed_printer_connection, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree, hf_rffpcnex_flags_delete_printer, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree, hf_rffpcnex_flags_set_printer, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree, hf_rffpcnex_flags_add_printer, tvb,
offset - 4, 4, flags);
if (flags & SPOOLSS_PRINTER_CHANGE_PRINTER)
proto_item_append_text(flags_item, ", change printer");
if (flags & SPOOLSS_PRINTER_CHANGE_JOB)
proto_item_append_text(flags_item, ", change job");
if (flags & SPOOLSS_PRINTER_CHANGE_FORM)
proto_item_append_text(flags_item, ", change form");
if (flags & SPOOLSS_PRINTER_CHANGE_PORT)
proto_item_append_text(flags_item, ", change port");
if (flags & SPOOLSS_PRINTER_CHANGE_PRINTER_DRIVER)
proto_item_append_text(flags_item, ", change printer driver");
offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, di, drep, offset = dissect_ndr_uint32(tvb, offset, pinfo, tree, di, drep,
hf_rffpcnex_options, NULL); hf_rffpcnex_options, NULL);
@ -3934,49 +3695,24 @@ SpoolssEnumPrinters_q(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_tree *tree, dcerpc_info *di, guint8 *drep _U_) proto_tree *tree, dcerpc_info *di, guint8 *drep _U_)
{ {
guint32 level, flags; guint32 level, flags;
proto_tree *flags_subtree;
proto_item *flags_item;
dcerpc_call_value *dcv = (dcerpc_call_value *)di->call_data; dcerpc_call_value *dcv = (dcerpc_call_value *)di->call_data;
static const int * hf_flags[] = {
&hf_enumprinters_flags_network,
&hf_enumprinters_flags_shared,
&hf_enumprinters_flags_remote,
&hf_enumprinters_flags_name,
&hf_enumprinters_flags_connections,
&hf_enumprinters_flags_local,
&hf_enumprinters_flags_default,
NULL
};
/* Parse packet */ /* Parse packet */
offset = dissect_ndr_uint32( offset = dissect_ndr_uint32(tvb, offset, pinfo, NULL, di, drep, -1, &flags);
tvb, offset, pinfo, NULL, di, drep,
hf_enumprinters_flags, &flags);
flags_item = proto_tree_add_text(tree, tvb, offset - 4, 4, proto_tree_add_bitmask_value(tree, tvb, offset - 4, hf_enumprinters_flags,
"Flags: 0x%08x", flags); ett_enumprinters_flags, hf_flags, flags);
flags_subtree = proto_item_add_subtree(
flags_item, ett_enumprinters_flags);
proto_tree_add_boolean(
flags_subtree, hf_enumprinters_flags_network, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree, hf_enumprinters_flags_shared, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree, hf_enumprinters_flags_remote, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree, hf_enumprinters_flags_name, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree, hf_enumprinters_flags_connections, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree, hf_enumprinters_flags_local, tvb,
offset - 4, 4, flags);
proto_tree_add_boolean(
flags_subtree, hf_enumprinters_flags_default, tvb,
offset - 4, 4, flags);
offset = dissect_ndr_str_pointer_item( offset = dissect_ndr_str_pointer_item(
tvb, offset, pinfo, tree, di, drep, tvb, offset, pinfo, tree, di, drep,

127
epan/dissectors/packet-dcerpc.c
View File

@ -4371,22 +4371,21 @@ dissect_dcerpc_cn_rts(tvbuff_t *tvb, gint offset, packet_info *pinfo,
guint32 *cmd; guint32 *cmd;
guint32 i; guint32 i;
const char *info_str = NULL; const char *info_str = NULL;
static const int * flags[] = {
&hf_dcerpc_cn_rts_flags_none,
&hf_dcerpc_cn_rts_flags_ping,
&hf_dcerpc_cn_rts_flags_other_cmd,
&hf_dcerpc_cn_rts_flags_recycle_channel,
&hf_dcerpc_cn_rts_flags_in_channel,
&hf_dcerpc_cn_rts_flags_out_channel,
&hf_dcerpc_cn_rts_flags_eof,
NULL
};
/* Dissect specific RTS header */ /* Dissect specific RTS header */
rts_flags = dcerpc_tvb_get_ntohs(tvb, offset, hdr->drep); rts_flags = dcerpc_tvb_get_ntohs(tvb, offset, hdr->drep);
if (dcerpc_tree) { proto_tree_add_bitmask_value_with_flags(dcerpc_tree, tvb, offset, hf_dcerpc_cn_rts_flags,
proto_tree *cn_rts_flags_tree; ett_dcerpc_cn_rts_flags, flags, rts_flags, BMT_NO_APPEND);
tf = proto_tree_add_uint(dcerpc_tree, hf_dcerpc_cn_rts_flags, tvb, offset, 2, rts_flags);
cn_rts_flags_tree = proto_item_add_subtree(tf, ett_dcerpc_cn_rts_flags);
proto_tree_add_boolean(cn_rts_flags_tree, hf_dcerpc_cn_rts_flags_none, tvb, offset, 1, rts_flags);
proto_tree_add_boolean(cn_rts_flags_tree, hf_dcerpc_cn_rts_flags_ping, tvb, offset, 1, rts_flags);
proto_tree_add_boolean(cn_rts_flags_tree, hf_dcerpc_cn_rts_flags_other_cmd, tvb, offset, 1, rts_flags);
proto_tree_add_boolean(cn_rts_flags_tree, hf_dcerpc_cn_rts_flags_recycle_channel, tvb, offset, 1, rts_flags);
proto_tree_add_boolean(cn_rts_flags_tree, hf_dcerpc_cn_rts_flags_in_channel, tvb, offset, 1, rts_flags);
proto_tree_add_boolean(cn_rts_flags_tree, hf_dcerpc_cn_rts_flags_out_channel, tvb, offset, 1, rts_flags);
proto_tree_add_boolean(cn_rts_flags_tree, hf_dcerpc_cn_rts_flags_eof, tvb, offset, 1, rts_flags);
}
offset += 2; offset += 2;
offset = dissect_dcerpc_uint16(tvb, offset, pinfo, dcerpc_tree, hdr->drep, offset = dissect_dcerpc_uint16(tvb, offset, pinfo, dcerpc_tree, hdr->drep,
@ -4713,12 +4712,22 @@ dissect_dcerpc_cn(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_item *ti = NULL; proto_item *ti = NULL;
proto_item *tf = NULL; proto_item *tf = NULL;
proto_tree *dcerpc_tree = NULL; proto_tree *dcerpc_tree = NULL;
proto_tree *cn_flags_tree = NULL;
proto_tree *drep_tree = NULL; proto_tree *drep_tree = NULL;
e_dce_cn_common_hdr_t hdr; e_dce_cn_common_hdr_t hdr;
dcerpc_auth_info auth_info; dcerpc_auth_info auth_info;
tvbuff_t *fragment_tvb; tvbuff_t *fragment_tvb;
dcerpc_decode_as_data* decode_data = dcerpc_get_decode_data(pinfo); dcerpc_decode_as_data* decode_data = dcerpc_get_decode_data(pinfo);
static const int * hdr_flags[] = {
&hf_dcerpc_cn_flags_object,
&hf_dcerpc_cn_flags_maybe,
&hf_dcerpc_cn_flags_dne,
&hf_dcerpc_cn_flags_mpx,
&hf_dcerpc_cn_flags_reserved,
&hf_dcerpc_cn_flags_cancel_pending,
&hf_dcerpc_cn_flags_last_frag,
&hf_dcerpc_cn_flags_first_frag,
NULL
};
/* /*
* when done over nbt, dcerpc requests are padded with 4 bytes of null * when done over nbt, dcerpc requests are padded with 4 bytes of null
@ -4819,18 +4828,10 @@ dissect_dcerpc_cn(tvbuff_t *tvb, int offset, packet_info *pinfo,
proto_item_append_text(ti, " %s, Fragment: %s", proto_item_append_text(ti, " %s, Fragment: %s",
val_to_str(hdr.ptype, pckt_vals, "Unknown (0x%02x)"), val_to_str(hdr.ptype, pckt_vals, "Unknown (0x%02x)"),
fragment_type(hdr.flags)); fragment_type(hdr.flags));
tf = proto_tree_add_uint(dcerpc_tree, hf_dcerpc_cn_flags, tvb, offset, 1, hdr.flags);
cn_flags_tree = proto_item_add_subtree(tf, ett_dcerpc_cn_flags);
} }
proto_tree_add_boolean(cn_flags_tree, hf_dcerpc_cn_flags_object, tvb, offset, 1, hdr.flags);
proto_tree_add_boolean(cn_flags_tree, hf_dcerpc_cn_flags_maybe, tvb, offset, 1, hdr.flags); proto_tree_add_bitmask_value_with_flags(dcerpc_tree, tvb, offset, hf_dcerpc_cn_flags,
proto_tree_add_boolean(cn_flags_tree, hf_dcerpc_cn_flags_dne, tvb, offset, 1, hdr.flags); ett_dcerpc_cn_flags, hdr_flags, hdr.flags, BMT_NO_APPEND);
proto_tree_add_boolean(cn_flags_tree, hf_dcerpc_cn_flags_mpx, tvb, offset, 1, hdr.flags);
proto_tree_add_boolean(cn_flags_tree, hf_dcerpc_cn_flags_reserved, tvb, offset, 1, hdr.flags);
proto_tree_add_boolean(cn_flags_tree, hf_dcerpc_cn_flags_cancel_pending, tvb, offset, 1, hdr.flags);
proto_tree_add_boolean(cn_flags_tree, hf_dcerpc_cn_flags_last_frag, tvb, offset, 1, hdr.flags);
proto_tree_add_boolean(cn_flags_tree, hf_dcerpc_cn_flags_first_frag, tvb, offset, 1, hdr.flags);
offset++; offset++;
col_append_fstr(pinfo->cinfo, COL_INFO, ", Fragment: %s", fragment_type(hdr.flags)); col_append_fstr(pinfo->cinfo, COL_INFO, ", Fragment: %s", fragment_type(hdr.flags));
@ -5616,8 +5617,6 @@ dissect_dcerpc_dg(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *dat
proto_item *ti = NULL; proto_item *ti = NULL;
proto_item *tf = NULL; proto_item *tf = NULL;
proto_tree *dcerpc_tree = NULL; proto_tree *dcerpc_tree = NULL;
proto_tree *dg_flags1_tree = NULL;
proto_tree *dg_flags2_tree = NULL;
proto_tree *drep_tree = NULL; proto_tree *drep_tree = NULL;
e_dce_dg_common_hdr_t hdr; e_dce_dg_common_hdr_t hdr;
int offset = 0; int offset = 0;
@ -5625,6 +5624,29 @@ dissect_dcerpc_dg(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *dat
int auth_level; int auth_level;
char *uuid_str; char *uuid_str;
const char *uuid_name = NULL; const char *uuid_name = NULL;
static const int * hdr_flags1[] = {
&hf_dcerpc_dg_flags1_rsrvd_80,
&hf_dcerpc_dg_flags1_broadcast,
&hf_dcerpc_dg_flags1_idempotent,
&hf_dcerpc_dg_flags1_maybe,
&hf_dcerpc_dg_flags1_nofack,
&hf_dcerpc_dg_flags1_frag,
&hf_dcerpc_dg_flags1_last_frag,
&hf_dcerpc_dg_flags1_rsrvd_01,
NULL
};
static const int * hdr_flags2[] = {
&hf_dcerpc_dg_flags2_rsrvd_80,
&hf_dcerpc_dg_flags2_rsrvd_40,
&hf_dcerpc_dg_flags2_rsrvd_20,
&hf_dcerpc_dg_flags2_rsrvd_10,
&hf_dcerpc_dg_flags2_rsrvd_08,
&hf_dcerpc_dg_flags2_rsrvd_04,
&hf_dcerpc_dg_flags2_cancel_pending,
&hf_dcerpc_dg_flags2_rsrvd_01,
NULL
};
/* /*
* Check if this looks like a CL DCERPC call. All dg packets * Check if this looks like a CL DCERPC call. All dg packets
@ -5703,57 +5725,18 @@ dissect_dcerpc_dg(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *dat
} }
offset = 0; offset = 0;
if (tree) proto_tree_add_uint(dcerpc_tree, hf_dcerpc_ver, tvb, offset, 1, hdr.rpc_ver);
proto_tree_add_uint(dcerpc_tree, hf_dcerpc_ver, tvb, offset, 1, hdr.rpc_ver);
offset++; offset++;
if (tree) proto_tree_add_uint(dcerpc_tree, hf_dcerpc_packet_type, tvb, offset, 1, hdr.ptype);
proto_tree_add_uint(dcerpc_tree, hf_dcerpc_packet_type, tvb, offset, 1, hdr.ptype);
offset++; offset++;
if (tree) { proto_tree_add_bitmask_value(dcerpc_tree, tvb, offset, hf_dcerpc_dg_flags1,
tf = proto_tree_add_uint(dcerpc_tree, hf_dcerpc_dg_flags1, tvb, offset, 1, hdr.flags1); ett_dcerpc_dg_flags1, hdr_flags1, hdr.flags1);
dg_flags1_tree = proto_item_add_subtree(tf, ett_dcerpc_dg_flags1);
if (dg_flags1_tree) {
proto_tree_add_boolean(dg_flags1_tree, hf_dcerpc_dg_flags1_rsrvd_80, tvb, offset, 1, hdr.flags1);
proto_tree_add_boolean(dg_flags1_tree, hf_dcerpc_dg_flags1_broadcast, tvb, offset, 1, hdr.flags1);
proto_tree_add_boolean(dg_flags1_tree, hf_dcerpc_dg_flags1_idempotent, tvb, offset, 1, hdr.flags1);
proto_tree_add_boolean(dg_flags1_tree, hf_dcerpc_dg_flags1_maybe, tvb, offset, 1, hdr.flags1);
proto_tree_add_boolean(dg_flags1_tree, hf_dcerpc_dg_flags1_nofack, tvb, offset, 1, hdr.flags1);
proto_tree_add_boolean(dg_flags1_tree, hf_dcerpc_dg_flags1_frag, tvb, offset, 1, hdr.flags1);
proto_tree_add_boolean(dg_flags1_tree, hf_dcerpc_dg_flags1_last_frag, tvb, offset, 1, hdr.flags1);
proto_tree_add_boolean(dg_flags1_tree, hf_dcerpc_dg_flags1_rsrvd_01, tvb, offset, 1, hdr.flags1);
if (hdr.flags1) {
proto_item_append_text(tf, " %s%s%s%s%s%s",
(hdr.flags1 & PFCL1_BROADCAST) ? "\"Broadcast\" " : "",
(hdr.flags1 & PFCL1_IDEMPOTENT) ? "\"Idempotent\" " : "",
(hdr.flags1 & PFCL1_MAYBE) ? "\"Maybe\" " : "",
(hdr.flags1 & PFCL1_NOFACK) ? "\"No Fack\" " : "",
(hdr.flags1 & PFCL1_FRAG) ? "\"Fragment\" " : "",
(hdr.flags1 & PFCL1_LASTFRAG) ? "\"Last Fragment\" " : "");
}
}
}
offset++; offset++;
if (tree) { proto_tree_add_bitmask_value(dcerpc_tree, tvb, offset, hf_dcerpc_dg_flags2,
tf = proto_tree_add_uint(dcerpc_tree, hf_dcerpc_dg_flags2, tvb, offset, 1, hdr.flags2); ett_dcerpc_dg_flags2, hdr_flags2, hdr.flags2);
dg_flags2_tree = proto_item_add_subtree(tf, ett_dcerpc_dg_flags2);
if (dg_flags2_tree) {
proto_tree_add_boolean(dg_flags2_tree, hf_dcerpc_dg_flags2_rsrvd_80, tvb, offset, 1, hdr.flags2);
proto_tree_add_boolean(dg_flags2_tree, hf_dcerpc_dg_flags2_rsrvd_40, tvb, offset, 1, hdr.flags2);
proto_tree_add_boolean(dg_flags2_tree, hf_dcerpc_dg_flags2_rsrvd_20, tvb, offset, 1, hdr.flags2);
proto_tree_add_boolean(dg_flags2_tree, hf_dcerpc_dg_flags2_rsrvd_10, tvb, offset, 1, hdr.flags2);
proto_tree_add_boolean(dg_flags2_tree, hf_dcerpc_dg_flags2_rsrvd_08, tvb, offset, 1, hdr.flags2);
proto_tree_add_boolean(dg_flags2_tree, hf_dcerpc_dg_flags2_rsrvd_04, tvb, offset, 1, hdr.flags2);
proto_tree_add_boolean(dg_flags2_tree, hf_dcerpc_dg_flags2_cancel_pending, tvb, offset, 1, hdr.flags2);
proto_tree_add_boolean(dg_flags2_tree, hf_dcerpc_dg_flags2_rsrvd_01, tvb, offset, 1, hdr.flags2);
if (hdr.flags2) {
proto_item_append_text(tf, " %s",
(hdr.flags2 & PFCL2_CANCEL_PENDING) ? "\"Cancel Pending\" " : "");
}
}
}
offset++; offset++;
if (tree) { if (tree) {

27
epan/dissectors/packet-dcom-dispatch.c
View File

@ -270,10 +270,15 @@ dissect_IDispatch_Invoke_rqst(tvbuff_t *tvb, int offset,
guint32 u32TmpOffset; guint32 u32TmpOffset;
guint32 u32SubStart; guint32 u32SubStart;
proto_item *feature_item;
proto_tree *feature_tree;
proto_item *dispparams_item; proto_item *dispparams_item;
proto_tree *dispparams_tree; proto_tree *dispparams_tree;
static const int * flags[] = {
&hf_dispatch_flags_propputref,
&hf_dispatch_flags_propput,
&hf_dispatch_flags_propget,
&hf_dispatch_flags_method,
NULL
};
offset = dissect_dcom_this(tvb, offset, pinfo, tree, di, drep); offset = dissect_dcom_this(tvb, offset, pinfo, tree, di, drep);
@ -288,31 +293,21 @@ dissect_IDispatch_Invoke_rqst(tvbuff_t *tvb, int offset,
hf_dispatch_lcid, &u32Lcid); hf_dispatch_lcid, &u32Lcid);
/* dispatch flags */ /* dispatch flags */
u32TmpOffset = dissect_dcom_DWORD(tvb, offset, pinfo, NULL, di, drep, u32TmpOffset = dissect_dcom_DWORD(tvb, offset, pinfo, NULL, di, drep, -1, &u32Flags);
hf_dispatch_flags, &u32Flags);
feature_item = proto_tree_add_uint (tree, hf_dispatch_flags, tvb, offset, 4, u32Flags); proto_tree_add_bitmask_value(tree, tvb, offset, hf_dispatch_flags,
feature_tree = proto_item_add_subtree (feature_item, ett_dispatch_flags); ett_dispatch_flags, flags, u32Flags);
if (feature_tree) {
proto_tree_add_boolean (feature_tree, hf_dispatch_flags_propputref, tvb, offset, 4, u32Flags);
proto_tree_add_boolean (feature_tree, hf_dispatch_flags_propput, tvb, offset, 4, u32Flags);
proto_tree_add_boolean (feature_tree, hf_dispatch_flags_propget, tvb, offset, 4, u32Flags);
proto_tree_add_boolean (feature_tree, hf_dispatch_flags_method, tvb, offset, 4, u32Flags);
}
if (u32Flags & DISPATCH_FLAGS_METHOD) { if (u32Flags & DISPATCH_FLAGS_METHOD) {
proto_item_append_text(feature_item, ", Method");
col_append_str(pinfo->cinfo, COL_INFO, " Method"); col_append_str(pinfo->cinfo, COL_INFO, " Method");
} }
if (u32Flags & DISPATCH_FLAGS_PROPGET) { if (u32Flags & DISPATCH_FLAGS_PROPGET) {
proto_item_append_text(feature_item, ", PropertyGet");
col_append_str(pinfo->cinfo, COL_INFO, " PropertyGet"); col_append_str(pinfo->cinfo, COL_INFO, " PropertyGet");
} }
if (u32Flags & DISPATCH_FLAGS_PROPPUT) { if (u32Flags & DISPATCH_FLAGS_PROPPUT) {
proto_item_append_text(feature_item, ", PropertyPut");
col_append_str(pinfo->cinfo, COL_INFO, " PropertyPut"); col_append_str(pinfo->cinfo, COL_INFO, " PropertyPut");
} }
if (u32Flags & DISPATCH_FLAGS_PROPPUTREF) { if (u32Flags & DISPATCH_FLAGS_PROPPUTREF) {
proto_item_append_text(feature_item, ", PropertyPutRef");
col_append_str(pinfo->cinfo, COL_INFO, " PropertyPutRef"); col_append_str(pinfo->cinfo, COL_INFO, " PropertyPutRef");
} }

37
epan/dissectors/packet-dcom.c
View File

@ -1170,8 +1170,20 @@ dissect_dcom_SAFEARRAY(tvbuff_t *tvb, int offset, packet_info *pinfo,
guint32 u32SubStart; guint32 u32SubStart;
guint32 u32TmpOffset; guint32 u32TmpOffset;
proto_item *feature_item; static const int * features[] = {
proto_tree *feature_tree; &hf_dcom_sa_features_variant,
&hf_dcom_sa_features_dispatch,
&hf_dcom_sa_features_unknown,
&hf_dcom_sa_features_bstr,
&hf_dcom_sa_features_have_vartype,
&hf_dcom_sa_features_have_iid,
&hf_dcom_sa_features_record,
&hf_dcom_sa_features_fixedsize,
&hf_dcom_sa_features_embedded,
&hf_dcom_sa_features_static,
&hf_dcom_sa_features_auto,
NULL
};
/* XXX: which alignment do we need here? */ /* XXX: which alignment do we need here? */
@ -1189,23 +1201,10 @@ dissect_dcom_SAFEARRAY(tvbuff_t *tvb, int offset, packet_info *pinfo,
hf_dcom_sa_dims16, &u16Dims); hf_dcom_sa_dims16, &u16Dims);
/* feature flags */ /* feature flags */
u32TmpOffset = dissect_dcom_WORD(tvb, offset, pinfo, NULL, di, drep, u32TmpOffset = dissect_dcom_WORD(tvb, offset, pinfo, NULL, di, drep, -1, &u16Features);
hf_dcom_sa_features, &u16Features);
feature_item = proto_tree_add_uint (sub_tree, hf_dcom_sa_features, tvb, offset, 2, u16Features); proto_tree_add_bitmask_value_with_flags(sub_tree, tvb, offset, hf_dcom_sa_features,
feature_tree = proto_item_add_subtree (feature_item, ett_dcom_sa_features); ett_dcom_sa_features, features, u16Features, BMT_NO_APPEND);
if (feature_tree) {
proto_tree_add_boolean (feature_tree, hf_dcom_sa_features_variant, tvb, offset, 2, u16Features);
proto_tree_add_boolean (feature_tree, hf_dcom_sa_features_dispatch, tvb, offset, 2, u16Features);
proto_tree_add_boolean (feature_tree, hf_dcom_sa_features_unknown, tvb, offset, 2, u16Features);
proto_tree_add_boolean (feature_tree, hf_dcom_sa_features_bstr, tvb, offset, 2, u16Features);
proto_tree_add_boolean (feature_tree, hf_dcom_sa_features_have_vartype, tvb, offset, 2, u16Features);
proto_tree_add_boolean (feature_tree, hf_dcom_sa_features_have_iid, tvb, offset, 2, u16Features);
proto_tree_add_boolean (feature_tree, hf_dcom_sa_features_record, tvb, offset, 2, u16Features);
proto_tree_add_boolean (feature_tree, hf_dcom_sa_features_fixedsize, tvb, offset, 2, u16Features);
proto_tree_add_boolean (feature_tree, hf_dcom_sa_features_embedded, tvb, offset, 2, u16Features);
proto_tree_add_boolean (feature_tree, hf_dcom_sa_features_static, tvb, offset, 2, u16Features);
proto_tree_add_boolean (feature_tree, hf_dcom_sa_features_auto, tvb, offset, 2, u16Features);
}
offset = u32TmpOffset; offset = u32TmpOffset;
offset = dissect_dcom_DWORD(tvb, offset, pinfo, sub_tree, di, drep, offset = dissect_dcom_DWORD(tvb, offset, pinfo, sub_tree, di, drep,

116
epan/dissectors/packet-fc.c
View File

@ -606,106 +606,24 @@ dissect_fc_vft(proto_tree *parent_tree,
static void static void
dissect_fc_fctl(packet_info *pinfo _U_, proto_tree *parent_tree, tvbuff_t *tvb, int offset) dissect_fc_fctl(packet_info *pinfo _U_, proto_tree *parent_tree, tvbuff_t *tvb, int offset)
{ {
proto_item *item; static const int * flags[] = {
proto_tree *tree; &hf_fc_fctl_exchange_responder,
guint32 flags; &hf_fc_fctl_seq_recipient,
&hf_fc_fctl_exchange_first,
flags = tvb_get_guint8 (tvb, offset); &hf_fc_fctl_exchange_last,
flags = (flags<<8) | tvb_get_guint8 (tvb, offset+1); &hf_fc_fctl_seq_last,
flags = (flags<<8) | tvb_get_guint8 (tvb, offset+2); &hf_fc_fctl_priority,
&hf_fc_fctl_transfer_seq_initiative,
item=proto_tree_add_uint(parent_tree, hf_fc_fctl, tvb, offset, 3, flags); &hf_fc_fctl_last_data_frame,
tree=proto_item_add_subtree(item, ett_fctl); &hf_fc_fctl_ack_0_1,
&hf_fc_fctl_rexmitted_seq,
proto_tree_add_boolean(tree, hf_fc_fctl_exchange_responder, tvb, offset, 3, flags); &hf_fc_fctl_abts_ack,
if (flags&FC_FCTL_EXCHANGE_RESPONDER){ &hf_fc_fctl_rel_offset,
proto_item_append_text(item, " Exchange Responder"); NULL
if (flags & (~( FC_FCTL_EXCHANGE_RESPONDER ))) };
proto_item_append_text(item, ",");
} else {
proto_item_append_text(item, " Exchange Originator");
if (flags & (~( FC_FCTL_EXCHANGE_RESPONDER )))
proto_item_append_text(item, ",");
}
flags&=(~( FC_FCTL_EXCHANGE_RESPONDER ));
proto_tree_add_boolean(tree, hf_fc_fctl_seq_recipient, tvb, offset, 3, flags);
if (flags&FC_FCTL_SEQ_RECIPIENT){
proto_item_append_text(item, " Seq Recipient");
if (flags & (~( FC_FCTL_SEQ_RECIPIENT )))
proto_item_append_text(item, ",");
} else {
proto_item_append_text(item, " Seq Initiator");
if (flags & (~( FC_FCTL_SEQ_RECIPIENT )))
proto_item_append_text(item, ",");
}
flags&=(~( FC_FCTL_SEQ_RECIPIENT ));
proto_tree_add_boolean(tree, hf_fc_fctl_exchange_first, tvb, offset, 3, flags);
if (flags&FC_FCTL_EXCHANGE_FIRST){
proto_item_append_text(item, " Exchg First");
if (flags & (~( FC_FCTL_EXCHANGE_FIRST )))
proto_item_append_text(item, ",");
}
flags&=(~( FC_FCTL_EXCHANGE_FIRST ));
proto_tree_add_boolean(tree, hf_fc_fctl_exchange_last, tvb, offset, 3, flags);
if (flags&FC_FCTL_EXCHANGE_LAST){
proto_item_append_text(item, " Exchg Last");
if (flags & (~( FC_FCTL_EXCHANGE_LAST )))
proto_item_append_text(item, ",");
}
flags&=(~( FC_FCTL_EXCHANGE_LAST ));
proto_tree_add_boolean(tree, hf_fc_fctl_seq_last, tvb, offset, 3, flags);
if (flags&FC_FCTL_SEQ_LAST){
proto_item_append_text(item, " Seq Last");
if (flags & (~( FC_FCTL_SEQ_LAST )))
proto_item_append_text(item, ",");
}
flags&=(~( FC_FCTL_SEQ_LAST ));
proto_tree_add_boolean(tree, hf_fc_fctl_priority, tvb, offset, 3, flags);
if (flags&FC_FCTL_PRIORITY){
proto_item_append_text(item, " Priority");
if (flags & (~( FC_FCTL_PRIORITY )))
proto_item_append_text(item, ",");
} else {
proto_item_append_text(item, " CS_CTL");
if (flags & (~( FC_FCTL_PRIORITY )))
proto_item_append_text(item, ",");
}
flags&=(~( FC_FCTL_PRIORITY ));
proto_tree_add_boolean(tree, hf_fc_fctl_transfer_seq_initiative, tvb, offset, 3, flags);
if (flags&FC_FCTL_TRANSFER_SEQ_INITIATIVE){
proto_item_append_text(item, " Transfer Seq Initiative");
if (flags & (~( FC_FCTL_TRANSFER_SEQ_INITIATIVE )))
proto_item_append_text(item, ",");
}
flags&=(~( FC_FCTL_TRANSFER_SEQ_INITIATIVE ));
proto_tree_add_uint(tree, hf_fc_fctl_last_data_frame, tvb, offset, 3, flags);
proto_tree_add_uint(tree, hf_fc_fctl_ack_0_1, tvb, offset, 3, flags);
proto_tree_add_boolean(tree, hf_fc_fctl_rexmitted_seq, tvb, offset, 3, flags);
if (flags&FC_FCTL_REXMITTED_SEQ){
proto_item_append_text(item, " Rexmitted Seq");
if (flags & (~( FC_FCTL_REXMITTED_SEQ )))
proto_item_append_text(item, ",");
}
flags&=(~( FC_FCTL_REXMITTED_SEQ ));
proto_tree_add_uint(tree, hf_fc_fctl_abts_ack, tvb, offset, 3, flags);
proto_tree_add_boolean(tree, hf_fc_fctl_rel_offset, tvb, offset, 3, flags);
if (flags&FC_FCTL_REL_OFFSET){
proto_item_append_text(item, " Rel Offset");
if (flags & (~( FC_FCTL_REL_OFFSET )))
proto_item_append_text(item, ",");
}
proto_tree_add_bitmask_with_flags(parent_tree, tvb, offset, hf_fc_fctl,
ett_fctl, flags, ENC_BIG_ENDIAN, BMT_NO_INT);
} }
static const value_string fc_bls_proto_val[] = { static const value_string fc_bls_proto_val[] = {

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

@ -393,51 +393,18 @@ fcdns_init_protocol(void)
static void static void
dissect_cos_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, const header_field_info *hfinfo) dissect_cos_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, const header_field_info *hfinfo)
{ {
proto_item *item; static const int * flags[] = {
proto_tree *tree; &hfi_fcdns_cos_f.id,
guint32 flags; &hfi_fcdns_cos_1.id,
&hfi_fcdns_cos_2.id,
&hfi_fcdns_cos_3.id,
&hfi_fcdns_cos_4.id,
&hfi_fcdns_cos_6.id,
NULL
};
flags = tvb_get_ntohl (tvb, offset); proto_tree_add_bitmask_with_flags(parent_tree, tvb, offset, hfinfo->id,
ett_cos_flags, flags, ENC_BIG_ENDIAN, BMT_NO_FALSE|BMT_NO_TFS);
item=proto_tree_add_uint(parent_tree, hfinfo,
tvb, offset, 1, flags);
tree=proto_item_add_subtree(item, ett_cos_flags);
proto_tree_add_boolean(tree, &hfi_fcdns_cos_f, tvb, offset, 4, flags);
if (flags&0x01){
proto_item_append_text(item, " F");
}
flags&=(~( 0x01 ));
proto_tree_add_boolean(tree, &hfi_fcdns_cos_1, tvb, offset, 4, flags);
if (flags&0x02){
proto_item_append_text(item, " 1");
}
flags&=(~( 0x02 ));
proto_tree_add_boolean(tree, &hfi_fcdns_cos_2, tvb, offset, 4, flags);
if (flags&0x04){
proto_item_append_text(item, " 2");
}
flags&=(~( 0x04 ));
proto_tree_add_boolean(tree, &hfi_fcdns_cos_3, tvb, offset, 4, flags);
if (flags&0x08){
proto_item_append_text(item, " 3");
}
flags&=(~( 0x08 ));
proto_tree_add_boolean(tree, &hfi_fcdns_cos_4, tvb, offset, 4, flags);
if (flags&0x10){
proto_item_append_text(item, " 4");
}
flags&=(~( 0x10 ));
proto_tree_add_boolean(tree, &hfi_fcdns_cos_6, tvb, offset, 4, flags);
if (flags&0x40){
proto_item_append_text(item, " 6");
}
/*flags&=(~( 0x40 ));*/
} }
@ -448,32 +415,23 @@ dissect_cos_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, const hea
static void static void
dissect_fc4features_and_type (proto_tree *parent_tree, tvbuff_t *tvb, int offset) dissect_fc4features_and_type (proto_tree *parent_tree, tvbuff_t *tvb, int offset)
{ {
proto_item *item; guint8 type;
proto_tree *tree; static const int * flags[] = {
guint8 flags, type; &hfi_fcdns_fc4features_i.id,
&hfi_fcdns_fc4features_t.id,
NULL
};
flags = tvb_get_guint8(tvb, offset);
type = tvb_get_guint8(tvb, offset+1); type = tvb_get_guint8(tvb, offset+1);
item=proto_tree_add_uint(parent_tree, &hfi_fcdns_fc4features,
tvb, offset, 1, flags);
tree=proto_item_add_subtree(item, ett_fc4features);
if(type==FC_TYPE_SCSI){ if(type==FC_TYPE_SCSI){
proto_tree_add_boolean(tree, &hfi_fcdns_fc4features_i, tvb, offset, 1, flags); proto_tree_add_bitmask_with_flags(parent_tree, tvb, offset, hfi_fcdns_fc4features.id,
if (flags&0x02){ ett_fc4features, flags, ENC_NA, BMT_NO_FALSE|BMT_NO_TFS);
proto_item_append_text(item, " I"); } else {
} proto_tree_add_item(parent_tree, &hfi_fcdns_fc4features, tvb, offset, 1, ENC_NA);
flags&=(~( 0x02 ));
proto_tree_add_boolean(tree, &hfi_fcdns_fc4features_t, tvb, offset, 1, flags);
if (flags&0x01){
proto_item_append_text(item, " T");
}
/*flags&=(~( 0x01 ));*/
} }
proto_tree_add_item (tree, &hfi_fcdns_req_fc4type, tvb, offset+1, 1, ENC_BIG_ENDIAN); proto_tree_add_item (parent_tree, &hfi_fcdns_req_fc4type, tvb, offset+1, 1, ENC_BIG_ENDIAN);
} }
/* The feature routines just decode FCP's FC-4 features field /* The feature routines just decode FCP's FC-4 features field
@ -481,26 +439,14 @@ dissect_fc4features_and_type (proto_tree *parent_tree, tvbuff_t *tvb, int offset
static void static void
dissect_fc4features (proto_tree *parent_tree, tvbuff_t *tvb, int offset) dissect_fc4features (proto_tree *parent_tree, tvbuff_t *tvb, int offset)
{ {
proto_item *item; static const int * flags[] = {
proto_tree *tree; &hfi_fcdns_fc4features_i.id,
guint8 flags; &hfi_fcdns_fc4features_t.id,
NULL
};
flags = tvb_get_guint8(tvb, offset); proto_tree_add_bitmask(parent_tree, tvb, offset, hfi_fcdns_fc4features_i.id,
item=proto_tree_add_uint(parent_tree, &hfi_fcdns_fc4features, ett_fc4features, flags, ENC_NA);
tvb, offset, 1, flags);
tree=proto_item_add_subtree(item, ett_fc4features);
proto_tree_add_boolean(tree, &hfi_fcdns_fc4features_i, tvb, offset, 1, flags);
if (flags&0x02){
proto_item_append_text(item, " I");
}
flags&=(~( 0x02 ));
proto_tree_add_boolean(tree, &hfi_fcdns_fc4features_t, tvb, offset, 1, flags);
if (flags&0x01){
proto_item_append_text(item, " T");
}
/*flags&=(~( 0x01 ));*/
} }

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

@ -678,102 +678,45 @@ static const true_false_string tfs_fc_fcels_cmn_payload = {
static void static void
dissect_cmnsvc (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint16 flags, guint8 opcode) dissect_cmnsvc (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint16 flags, guint8 opcode)
{ {
proto_item *item; static const int * common_flags[] = {
proto_tree *tree; &hf_fcels_cmn_cios,
&hf_fcels_cmn_rro,
&hf_fcels_cmn_vvv,
&hf_fcels_cmn_b2b,
&hf_fcels_cmn_multicast,
&hf_fcels_cmn_broadcast,
&hf_fcels_cmn_security,
&hf_fcels_cmn_clk,
&hf_fcels_cmn_dhd,
&hf_fcels_cmn_payload,
NULL
};
item=proto_tree_add_uint(parent_tree, hf_fcels_cmnfeatures, static const int * pflags[] = {
tvb, offset, 2, flags); &hf_fcels_cmn_cios,
tree=proto_item_add_subtree(item, ett_fcels_cmnfeatures); &hf_fcels_cmn_rro,
&hf_fcels_cmn_vvv,
&hf_fcels_cmn_b2b,
&hf_fcels_cmn_e_d_tov,
&hf_fcels_cmn_simplex,
&hf_fcels_cmn_multicast,
&hf_fcels_cmn_broadcast,
&hf_fcels_cmn_security,
&hf_fcels_cmn_clk,
&hf_fcels_cmn_dhd,
&hf_fcels_cmn_seqcnt,
&hf_fcels_cmn_payload,
NULL
};
proto_tree_add_boolean(tree, hf_fcels_cmn_cios, tvb, offset, 2, flags);
if (flags&0x8000){
proto_item_append_text(item, " Cont. Incr. Offset Supported");
}
flags&=(~( 0x8000 ));
proto_tree_add_boolean(tree, hf_fcels_cmn_rro, tvb, offset, 2, flags);
if (flags&0x4000){
proto_item_append_text(item, " RRO Supported");
}
flags&=(~( 0x4000 ));
proto_tree_add_boolean(tree, hf_fcels_cmn_vvv, tvb, offset, 2, flags);
if (flags&0x2000){
proto_item_append_text(item, " Valid Vendor Version");
}
flags&=(~( 0x2000 ));
proto_tree_add_boolean(tree, hf_fcels_cmn_b2b, tvb, offset, 2, flags);
if (flags&0x0800){
proto_item_append_text(item, " Alt B2B Credit Mgmt");
} else {
proto_item_append_text(item, " Normal B2B Credit Mgmt");
}
flags&=(~( 0x0800 ));
if ((opcode == FC_ELS_PLOGI) || (opcode == FC_ELS_PDISC)) { if ((opcode == FC_ELS_PLOGI) || (opcode == FC_ELS_PDISC)) {
proto_tree_add_boolean(tree, hf_fcels_cmn_e_d_tov, tvb, offset, 2, flags); proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_cmnfeatures,
if (flags&0x0400){ ett_fcels_cmnfeatures, pflags, flags, 0);
proto_item_append_text(item, " E_D_TOV Resolution in ns");
} else {
proto_item_append_text(item, " E_D_TOV Resolution in ms");
}
flags&=(~( 0x0400 ));
proto_tree_add_boolean(tree, hf_fcels_cmn_simplex, tvb, offset, 2, flags);
if (flags&0x0040){
proto_item_append_text(item, " Simplex Dedicated Conn Supported");
}
flags&=(~( 0x0040 ));
}
proto_tree_add_boolean(tree, hf_fcels_cmn_multicast, tvb, offset, 2, flags);
if (flags&0x0200){
proto_item_append_text(item, " Multicast Supported");
}
flags&=(~( 0x0200 ));
proto_tree_add_boolean(tree, hf_fcels_cmn_broadcast, tvb, offset, 2, flags);
if (flags&0x0100){
proto_item_append_text(item, " Broadcast Supported");
}
flags&=(~( 0x0100 ));
proto_tree_add_boolean(tree, hf_fcels_cmn_security, tvb, offset, 2, flags);
if (flags&0x0020){
proto_item_append_text(item, " Security Bit");
}
flags&=(~( 0x0020 ));
proto_tree_add_boolean(tree, hf_fcels_cmn_clk, tvb, offset, 2, flags);
if (flags&0x0010){
proto_item_append_text(item, " Clk Sync Prim Capable");
}
flags&=(~( 0x0010 ));
proto_tree_add_boolean(tree, hf_fcels_cmn_dhd, tvb, offset, 2, flags);
if (flags&0x0004){
proto_item_append_text(item, " DHD Capable");
}
flags&=(~( 0x0004 ));
if ((opcode == FC_ELS_PLOGI) || (opcode == FC_ELS_PDISC)) {
proto_tree_add_boolean(tree, hf_fcels_cmn_seqcnt, tvb, offset, 2, flags);
if (flags&0x0002){
proto_item_append_text(item, " Cont. Incr SEQCNT rules");
} else {
proto_item_append_text(item, " Normal SEQCNT rules");
}
flags&=(~( 0x0002 ));
}
proto_tree_add_boolean(tree, hf_fcels_cmn_payload, tvb, offset, 2, flags);
if (flags&0x0001){
proto_item_append_text(item, " Payload Len=256 bytes");
} else { } else {
proto_item_append_text(item, " Payload Len=116 bytes"); proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_cmnfeatures,
ett_fcels_cmnfeatures, common_flags, flags, 0);
} }
/*flags&=(~( 0x0001 ));*/
} }
@ -790,44 +733,26 @@ static const true_false_string tfs_fc_fcels_cls_nzctl = {
static void static void
dissect_clssvc_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint16 flags, guint8 opcode) dissect_clssvc_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint16 flags, guint8 opcode)
{ {
proto_item *item; static const int * common_flags[] = {
proto_tree *tree; &hf_fcels_cls_cns,
&hf_fcels_cls_prio,
NULL
};
item=proto_tree_add_uint(parent_tree, hf_fcels_clsflags, static const int * pflags[] = {
tvb, offset, 2, flags); &hf_fcels_cls_cns,
tree=proto_item_add_subtree(item, ett_fcels_clsflags); &hf_fcels_cls_sdr,
&hf_fcels_cls_prio,
proto_tree_add_boolean(tree, hf_fcels_cls_cns, tvb, offset, 2, flags); &hf_fcels_cls_nzctl,
if (!(flags&0x8000)){ NULL
proto_item_append_text(item, " Class Not Supported"); };
return;
}
flags&=(~( 0x8000 ));
if ((opcode == FC_ELS_FLOGI) || (opcode == FC_ELS_FDISC)) { if ((opcode == FC_ELS_FLOGI) || (opcode == FC_ELS_FDISC)) {
proto_tree_add_boolean(tree, hf_fcels_cls_sdr, tvb, offset, 2, flags); proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_clsflags,
if (flags&0x0800){ ett_fcels_clsflags, pflags, flags, 0);
proto_item_append_text(item, " Seq Delivery Requested"); } else {
} else { proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_clsflags,
proto_item_append_text(item, " Out of Order Delivery Requested"); ett_fcels_clsflags, common_flags, flags, 0);
}
flags&=(~( 0x0800 ));
}
proto_tree_add_boolean(tree, hf_fcels_cls_prio, tvb, offset, 2, flags);
if (flags&0x0080){
proto_item_append_text(item, " Priority/preemption Supported");
}
flags&=(~( 0x0080 ));
if ((opcode == FC_ELS_PLOGI) || (opcode == FC_ELS_PDISC)) {
proto_tree_add_boolean(tree, hf_fcels_cls_nzctl, tvb, offset, 2, flags);
if (flags & 0x0040) {
proto_item_append_text(item, " Non-zero CS_CTL Tolerated");
} else {
proto_item_append_text(item, " Non-zero CS_CTL Maybe Tolerated");
}
/*flags&=(~( 0x0040 ));*/
} }
} }
@ -863,67 +788,37 @@ static const true_false_string tfs_fc_fcels_fcpflags_wrxr = {
static void static void
dissect_fcp_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint32 flags, guint8 isreq) dissect_fcp_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint32 flags, guint8 isreq)
{ {
proto_item *item; static const int * req_flags[] = {
proto_tree *tree; &hf_fcels_fcpflags_trireq,
&hf_fcels_fcpflags_retry,
&hf_fcels_fcpflags_ccomp,
&hf_fcels_fcpflags_datao,
&hf_fcels_fcpflags_initiator,
&hf_fcels_fcpflags_target,
&hf_fcels_fcpflags_rdxr,
&hf_fcels_fcpflags_wrxr,
NULL
};
item=proto_tree_add_uint(parent_tree, hf_fcels_fcpflags, static const int * rep_flags[] = {
tvb, offset, 4, flags); &hf_fcels_fcpflags_trirep,
tree=proto_item_add_subtree(item, ett_fcels_fcpflags); &hf_fcels_fcpflags_retry,
&hf_fcels_fcpflags_ccomp,
&hf_fcels_fcpflags_datao,
&hf_fcels_fcpflags_initiator,
&hf_fcels_fcpflags_target,
&hf_fcels_fcpflags_rdxr,
&hf_fcels_fcpflags_wrxr,
NULL
};
if (isreq) { if (isreq) {
proto_tree_add_boolean(tree, hf_fcels_fcpflags_trireq, tvb, offset, 4, flags); proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_fcpflags,
if (flags&0x2000){ ett_fcels_fcpflags, req_flags, flags, BMT_NO_FALSE);
proto_item_append_text(item, " Task Retry Ident Req");
}
} else { } else {
proto_tree_add_boolean(tree, hf_fcels_fcpflags_trirep, tvb, offset, 4, flags); proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_fcpflags,
if (flags&0x2000){ ett_fcels_fcpflags, rep_flags, flags, BMT_NO_FALSE);
proto_item_append_text(item, " Task Retry Ident Acc");
}
} }
flags&=(~( 0x2000 ));
proto_tree_add_boolean(tree, hf_fcels_fcpflags_retry, tvb, offset, 4, flags);
if (flags&0x1000){
proto_item_append_text(item, " Retry Possible");
}
flags&=(~( 0x1000 ));
proto_tree_add_boolean(tree, hf_fcels_fcpflags_ccomp, tvb, offset, 4, flags);
if (flags&0x0080){
proto_item_append_text(item, " Confirmed Comp");
}
flags&=(~( 0x0080 ));
proto_tree_add_boolean(tree, hf_fcels_fcpflags_datao, tvb, offset, 4, flags);
if (flags&0x0040){
proto_item_append_text(item, " Data Overlay");
}
flags&=(~( 0x0040 ));
proto_tree_add_boolean(tree, hf_fcels_fcpflags_initiator, tvb, offset, 4, flags);
if (flags&0x0020){
proto_item_append_text(item, " Initiator");
}
flags&=(~( 0x0020 ));
proto_tree_add_boolean(tree, hf_fcels_fcpflags_target, tvb, offset, 4, flags);
if (flags&0x0010){
proto_item_append_text(item, " Target");
}
flags&=(~( 0x0010 ));
proto_tree_add_boolean(tree, hf_fcels_fcpflags_rdxr, tvb, offset, 4, flags);
if (flags&0x0002){
proto_item_append_text(item, " Rd Xfer_Rdy Dis");
}
flags&=(~( 0x0002 ));
proto_tree_add_boolean(tree, hf_fcels_fcpflags_wrxr, tvb, offset, 4, flags);
if (flags&0x0001){
proto_item_append_text(item, " Wr Xfer_Rdy Dis");
}
/*flags&=(~( 0x0001 ));*/
} }
@ -931,37 +826,17 @@ static void
dissect_speed_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint32 flags, int port) dissect_speed_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint32 flags, int port)
{ {
proto_item *item; proto_item *item;
proto_tree *tree; static const int * speed_flags[] = {
&hf_fcels_speedflags_1gb,
&hf_fcels_speedflags_2gb,
&hf_fcels_speedflags_4gb,
&hf_fcels_speedflags_10gb,
NULL
};
item=proto_tree_add_uint_format(parent_tree, hf_fcels_speedflags, item = proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_speedflags,
tvb, offset, 2, flags, ett_fcels_speedflags, speed_flags, flags, BMT_NO_FALSE|BMT_NO_TFS);
"Port Speed Capabilities (Port %u): 0x%04x", proto_item_set_text(item, "Port Speed Capabilities (Port %u): 0x%04x", port, flags);
port, flags);
tree=proto_item_add_subtree(item, ett_fcels_speedflags);
proto_tree_add_boolean(tree, hf_fcels_speedflags_1gb, tvb, offset, 2, flags);
if (flags&0x8000){
proto_item_append_text(item, " 1Gb");
}
flags&=(~( 0x8000 ));
proto_tree_add_boolean(tree, hf_fcels_speedflags_2gb, tvb, offset, 2, flags);
if (flags&0x4000){
proto_item_append_text(item, " 2Gb");
}
flags&=(~( 0x4000 ));
proto_tree_add_boolean(tree, hf_fcels_speedflags_4gb, tvb, offset, 2, flags);
if (flags&0x2000){
proto_item_append_text(item, " 4Gb");
}
flags&=(~( 0x2000 ));
proto_tree_add_boolean(tree, hf_fcels_speedflags_10gb, tvb, offset, 2, flags);
if (flags&0x1000){
proto_item_append_text(item, " 10Gb");
}
/*flags&=(~( 0x1000 ));*/
} }
static const true_false_string tfs_fc_fcels_tprloflags_gprlo = { static const true_false_string tfs_fc_fcels_tprloflags_gprlo = {
@ -980,66 +855,39 @@ static const true_false_string tfs_fc_fcels_prliloflags_eip = {
static void static void
dissect_prlilo_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, int flags, guint8 opcode) dissect_prlilo_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, int flags, guint8 opcode)
{ {
proto_item *item; static const int * tprlo_flags[] = {
proto_tree *tree; &hf_fcels_tprloflags_opav,
&hf_fcels_tprloflags_rpav,
&hf_fcels_tprloflags_npv,
&hf_fcels_tprloflags_gprlo,
NULL
};
item=proto_tree_add_uint(parent_tree, hf_fcels_prliloflags, static const int * prli_flags[] = {
tvb, offset, 1, flags); &hf_fcels_prliloflags_opav,
tree=proto_item_add_subtree(item, ett_fcels_prliloflags); &hf_fcels_tprloflags_rpav,
&hf_fcels_prliloflags_ipe,
NULL
};
static const int * not_prli_flags[] = {
&hf_fcels_prliloflags_opav,
&hf_fcels_tprloflags_rpav,
&hf_fcels_prliloflags_eip,
NULL
};
if (opcode == FC_ELS_TPRLO) { if (opcode == FC_ELS_TPRLO) {
proto_tree_add_boolean(tree, hf_fcels_tprloflags_opav, tvb, offset, 1, flags); proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_prliloflags,
if (flags&0x80){ ett_fcels_prliloflags, tprlo_flags, flags, BMT_NO_FALSE|BMT_NO_TFS);
proto_item_append_text(item, " 3rd Party Orig PA Valid");
}
flags&=(~( 0x80 ));
proto_tree_add_boolean(tree, hf_fcels_tprloflags_rpav, tvb, offset, 1, flags);
if (flags&0x40){
proto_item_append_text(item, " Resp PA Valid");
}
flags&=(~( 0x40 ));
proto_tree_add_boolean(tree, hf_fcels_tprloflags_npv, tvb, offset, 1, flags);
if (flags&0x20){
proto_item_append_text(item, " 3rd Party N_Port Valid");
}
flags&=(~( 0x20 ));
proto_tree_add_boolean(tree, hf_fcels_tprloflags_gprlo, tvb, offset, 1, flags);
if (flags&0x10){
proto_item_append_text(item, " Global PRLO");
}
/*flags&=(~( 0x10 ));*/
} else { /* opcode != TPRLO */ } else { /* opcode != TPRLO */
proto_tree_add_boolean(tree, hf_fcels_prliloflags_opav, tvb, offset, 1, flags);
if (flags&0x80){
proto_item_append_text(item, " Orig PA Valid");
}
flags&=(~( 0x80 ));
proto_tree_add_boolean(tree, hf_fcels_tprloflags_rpav, tvb, offset, 1, flags);
if (flags&0x40){
proto_item_append_text(item, " Resp PA Valid");
}
flags&=(~( 0x40 ));
if (opcode == FC_ELS_PRLI) { if (opcode == FC_ELS_PRLI) {
proto_tree_add_boolean(tree, hf_fcels_prliloflags_ipe, tvb, offset, 1, flags); proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_prliloflags,
if (flags&0x20){ ett_fcels_prliloflags, prli_flags, flags, BMT_NO_FALSE);
proto_item_append_text(item, " Image Pair Estd");
} else {
proto_item_append_text(item, " Image Pair NOT Estd");
}
/*flags&=(~( 0x20 ));*/
} else { } else {
proto_tree_add_boolean(tree, hf_fcels_prliloflags_eip, tvb, offset, 1, flags); proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_prliloflags,
if (flags&0x20){ ett_fcels_prliloflags, not_prli_flags, flags, BMT_NO_FALSE);
proto_item_append_text(item, " Est Image Pair & Exchg Svc Param");
} else {
proto_item_append_text(item, " Exchange Svc Param Only");
}
/*flags&=(~( 0x20 ));*/
} }
} }
} }
@ -1058,42 +906,26 @@ static const true_false_string tfs_fc_fcels_initctl_ackgaa = {
static void static void
dissect_initctl_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint16 flags, guint8 opcode) dissect_initctl_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint16 flags, guint8 opcode)
{ {
proto_item *item; static const int * plogi_flags[] = {
proto_tree *tree; &hf_fcels_initctl_initial_pa,
&hf_fcels_initctl_ack0,
&hf_fcels_initctl_ackgaa,
&hf_fcels_initctl_sync,
NULL
};
item=proto_tree_add_uint(parent_tree, hf_fcels_initctl, static const int * not_plogi_flags[] = {
tvb, offset, 2, flags); &hf_fcels_initctl_sync,
tree=proto_item_add_subtree(item, ett_fcels_initctl); NULL
};
if ((opcode == FC_ELS_PLOGI) || (opcode == FC_ELS_PDISC)) { if ((opcode == FC_ELS_PLOGI) || (opcode == FC_ELS_PDISC)) {
proto_tree_add_uint(tree, hf_fcels_initctl_initial_pa, proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_initctl,
tvb, offset, 2, flags); ett_fcels_initctl, plogi_flags, flags, BMT_NO_FALSE);
proto_item_append_text(item, " %s", } else {
val_to_str((flags&0x3000)>>12, initial_pa_vals, proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_initctl,
"0x%02x") ett_fcels_initctl, not_plogi_flags, flags, BMT_NO_FALSE);
);
flags&=(~( 0x3000 ));
proto_tree_add_boolean(tree, hf_fcels_initctl_ack0, tvb, offset, 2, flags);
if (flags&0x0800){
proto_item_append_text(item, " ACK0 Capable");
}
flags&=(~( 0x0800 ));
proto_tree_add_boolean(tree, hf_fcels_initctl_ackgaa, tvb, offset, 2, flags);
if (flags&0x0200){
proto_item_append_text(item, " ACK Generation Assistance Avail");
}
flags&=(~( 0x0200 ));
} }
proto_tree_add_boolean(tree, hf_fcels_initctl_sync, tvb, offset, 2, flags);
if (flags&0x0010){
proto_item_append_text(item, " Clock Sync ELS Supported");
}
/*flags&=(~( 0x0010 ));*/
} }
@ -1114,50 +946,27 @@ static const value_string rcptctl_category_vals[] = {
static void static void
dissect_rcptctl_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint16 flags, guint8 opcode) dissect_rcptctl_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint16 flags, guint8 opcode)
{ {
proto_item *item; static const int * plogi_flags[] = {
proto_tree *tree; &hf_fcels_rcptctl_ack0,
&hf_fcels_rcptctl_interlock,
&hf_fcels_rcptctl_policy,
&hf_fcels_rcptctl_category,
&hf_fcels_rcptctl_sync,
NULL
};
item=proto_tree_add_uint(parent_tree, hf_fcels_rcptctl, static const int * not_plogi_flags[] = {
tvb, offset, 2, flags); &hf_fcels_rcptctl_sync,
tree=proto_item_add_subtree(item, ett_fcels_rcptctl); NULL
};
if ((opcode == FC_ELS_PLOGI) || (opcode == FC_ELS_PDISC)) { if ((opcode == FC_ELS_PLOGI) || (opcode == FC_ELS_PDISC)) {
proto_tree_add_boolean(tree, hf_fcels_rcptctl_ack0, tvb, offset, 2, flags); proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_rcptctl,
if (flags&0x8000){ ett_fcels_rcptctl, plogi_flags, flags, BMT_NO_FALSE);
proto_item_append_text(item, " ACK0 Supported"); } else {
} else { proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_fcels_rcptctl,
proto_item_append_text(item, " ACK0 NOT Supported"); ett_fcels_rcptctl, not_plogi_flags, flags, BMT_NO_FALSE);
}
flags&=(~( 0x8000 ));
proto_tree_add_boolean(tree, hf_fcels_rcptctl_interlock, tvb, offset, 2, flags);
if (flags&0x2000){
proto_item_append_text(item, " X_ID Interlock Reqd");
}
flags&=(~( 0x2000 ));
proto_tree_add_uint(tree, hf_fcels_rcptctl_policy,
tvb, offset, 2, flags);
proto_item_append_text(item, " %s",
val_to_str((flags&0x1800)>>11, rcptctl_policy_vals,
"0x%02x")
);
flags&=(~( 0x1800 ));
proto_tree_add_uint(tree, hf_fcels_rcptctl_category,
tvb, offset, 2, flags);
proto_item_append_text(item, " %s",
val_to_str((flags&0x0030)>>4, rcptctl_category_vals,
"0x%02x")
);
flags&=(~( 0x0030 ));
} }
proto_tree_add_boolean(tree, hf_fcels_rcptctl_sync, tvb, offset, 2, flags);
if (flags&0x0008){
proto_item_append_text(item, " Clock Sync ELS Supported");
}
/*flags&=(~( 0x0008 ));*/
} }
/* Maximum length of possible string from, construct_*_string /* Maximum length of possible string from, construct_*_string

67
epan/dissectors/packet-fcfzs.c
View File

@ -211,36 +211,18 @@ dissect_fcfzs_zoneset(tvbuff_t *tvb, packet_info* pinfo, proto_tree *tree, int o
static void static void
dissect_fcfzs_gzc(tvbuff_t *tvb, int offset, proto_tree *parent_tree, gboolean isreq) dissect_fcfzs_gzc(tvbuff_t *tvb, int offset, proto_tree *parent_tree, gboolean isreq)
{ {
static const int * flags[] = {
&hf_fcfzs_gzc_flags_hard_zones,
&hf_fcfzs_gzc_flags_soft_zones,
&hf_fcfzs_gzc_flags_zoneset_db,
NULL
};
if (!isreq) { if (!isreq) {
guint8 flags; proto_tree_add_bitmask_with_flags(parent_tree, tvb, offset, hf_fcfzs_gzc_flags,
proto_item *item = NULL; ett_fcfzs_gzc_flags, flags, ENC_NA, BMT_NO_FALSE|BMT_NO_TFS);
proto_tree *tree = NULL;
flags = tvb_get_guint8(tvb, offset); proto_tree_add_item(parent_tree, hf_fcfzs_gzc_vendor, tvb, offset+4, 4, ENC_BIG_ENDIAN);
if (parent_tree) {
item = proto_tree_add_uint(parent_tree, hf_fcfzs_gzc_flags, tvb, offset, 1, flags);
tree = proto_item_add_subtree(item, ett_fcfzs_gzc_flags);
}
proto_tree_add_boolean(tree, hf_fcfzs_gzc_flags_hard_zones, tvb, offset, 1, flags);
if (flags & 0x80) {
proto_item_append_text(item, " Hard Zones");
}
flags &= (~( 0x80 ));
proto_tree_add_boolean(tree, hf_fcfzs_gzc_flags_soft_zones, tvb, offset, 1, flags);
if (flags & 0x40) {
proto_item_append_text(item, " Soft Zones");
}
flags &= (~( 0x40 ));
proto_tree_add_boolean(tree, hf_fcfzs_gzc_flags_zoneset_db, tvb, offset, 1, flags);
if (flags & 0x01) {
proto_item_append_text(item, " ZoneSet Database Available");
}
/*flags &= (~( 0x01 ));*/
proto_tree_add_item(tree, hf_fcfzs_gzc_vendor, tvb, offset+4, 4, ENC_BIG_ENDIAN);
} }
} }
@ -248,30 +230,15 @@ static void
dissect_fcfzs_gest(tvbuff_t *tvb, proto_tree *parent_tree, gboolean isreq) dissect_fcfzs_gest(tvbuff_t *tvb, proto_tree *parent_tree, gboolean isreq)
{ {
int offset = 16; /* past the fc_ct header */ int offset = 16; /* past the fc_ct header */
static const int * flags[] = {
&hf_fcfzs_soft_zone_set_enforced,
&hf_fcfzs_hard_zone_set_enforced,
NULL
};
if (!isreq) { if (!isreq) {
guint8 flags; proto_tree_add_bitmask_with_flags(parent_tree, tvb, offset, hf_fcfzs_zone_state,
proto_item *item = NULL; ett_fcfzs_zone_state, flags, ENC_NA, BMT_NO_FALSE|BMT_NO_TFS);
proto_tree *tree = NULL;
flags = tvb_get_guint8(tvb, offset);
if (parent_tree) {
item = proto_tree_add_uint(parent_tree, hf_fcfzs_zone_state, tvb, offset, 1, flags);
tree = proto_item_add_subtree(item, ett_fcfzs_zone_state);
}
proto_tree_add_boolean(tree, hf_fcfzs_soft_zone_set_enforced, tvb, offset, 1, flags);
if (flags & 0x80) {
proto_item_append_text(item, " Soft Zone Set Enforced");
}
flags &= (~( 0x80 ));
proto_tree_add_boolean(tree, hf_fcfzs_hard_zone_set_enforced, tvb, offset, 1, flags);
if (flags & 0x40) {
proto_item_append_text(item, " Hard Zone Set Enforced");
}
/*flags &= (~( 0x40 ));*/
proto_tree_add_item(parent_tree, hf_fcfzs_gest_vendor, tvb, offset+4, 4, ENC_BIG_ENDIAN); proto_tree_add_item(parent_tree, hf_fcfzs_gest_vendor, tvb, offset+4, 4, ENC_BIG_ENDIAN);
} }

152
epan/dissectors/packet-fcp.c
View File

@ -177,70 +177,53 @@ static void
dissect_task_mgmt_flags(packet_info *pinfo, proto_tree *parent_tree, tvbuff_t *tvb, int offset) dissect_task_mgmt_flags(packet_info *pinfo, proto_tree *parent_tree, tvbuff_t *tvb, int offset)
{ {
proto_item *item; proto_item *item;
proto_tree *tree; static const int * mgmt_flags[] = {
&hf_fcp_mgmt_flags_obsolete,
&hf_fcp_mgmt_flags_clear_aca,
&hf_fcp_mgmt_flags_target_reset,
&hf_fcp_mgmt_flags_lu_reset,
&hf_fcp_mgmt_flags_rsvd,
&hf_fcp_mgmt_flags_clear_task_set,
&hf_fcp_mgmt_flags_abort_task_set,
NULL
};
guint8 flags; guint8 flags;
item = proto_tree_add_item(parent_tree, hf_fcp_taskmgmt, tvb, offset, 1, ENC_LITTLE_ENDIAN);
tree = proto_item_add_subtree(item, ett_fcp_taskmgmt);
flags = tvb_get_guint8(tvb, offset); flags = tvb_get_guint8(tvb, offset);
item = proto_tree_add_bitmask_with_flags(parent_tree, tvb, offset, hf_fcp_taskmgmt,
ett_fcp_taskmgmt, mgmt_flags, ENC_NA, BMT_NO_FALSE|BMT_NO_TFS);
if (!flags) if (!flags)
proto_item_append_text(item, " (No values set)"); proto_item_append_text(item, " (No values set)");
proto_tree_add_boolean(tree, hf_fcp_mgmt_flags_obsolete, tvb, offset, 1, flags);
if (flags & 0x80) { if (flags & 0x80) {
proto_item_append_text(item, " OBSOLETE");
col_prepend_fence_fstr(pinfo->cinfo, COL_INFO, "[FCP OBSOLETE] "); col_prepend_fence_fstr(pinfo->cinfo, COL_INFO, "[FCP OBSOLETE] ");
} }
flags &= (~( 0x80 ));
proto_tree_add_boolean(tree, hf_fcp_mgmt_flags_clear_aca, tvb, offset, 1, flags);
if (flags & 0x40) { if (flags & 0x40) {
proto_item_append_text(item, " CLEAR ACA");
col_prepend_fence_fstr(pinfo->cinfo, COL_INFO, "[FCP CLEAR_ACA] "); col_prepend_fence_fstr(pinfo->cinfo, COL_INFO, "[FCP CLEAR_ACA] ");
} }
flags &= (~( 0x40 ));
proto_tree_add_boolean(tree, hf_fcp_mgmt_flags_target_reset, tvb, offset, 1, flags);
if (flags & 0x20) { if (flags & 0x20) {
proto_item_append_text(item, " TARGET RESET");
col_prepend_fence_fstr(pinfo->cinfo, COL_INFO, "[FCP TARGET_RESET] "); col_prepend_fence_fstr(pinfo->cinfo, COL_INFO, "[FCP TARGET_RESET] ");
} }
flags &= (~( 0x20 ));
proto_tree_add_boolean(tree, hf_fcp_mgmt_flags_lu_reset, tvb, offset, 1, flags);
if (flags & 0x10) { if (flags & 0x10) {
proto_item_append_text(item, " LU RESET");
col_prepend_fence_fstr(pinfo->cinfo, COL_INFO, "[FCP LU_RESET] "); col_prepend_fence_fstr(pinfo->cinfo, COL_INFO, "[FCP LU_RESET] ");
} }
flags &= (~( 0x10 ));
proto_tree_add_boolean(tree, hf_fcp_mgmt_flags_rsvd, tvb, offset, 1, flags);
if (flags & 0x08) { if (flags & 0x08) {
proto_item_append_text(item, " RSVD");
col_prepend_fence_fstr(pinfo->cinfo, COL_INFO, "[FCP RSVD] "); col_prepend_fence_fstr(pinfo->cinfo, COL_INFO, "[FCP RSVD] ");
} }
flags &= (~( 0x08 ));
proto_tree_add_boolean(tree, hf_fcp_mgmt_flags_clear_task_set, tvb, offset, 1, flags);
if (flags & 0x04) { if (flags & 0x04) {
proto_item_append_text(item, " CLEAR TASK SET");
col_prepend_fence_fstr(pinfo->cinfo, COL_INFO, "[FCP CLEAR_TASK_SET] "); col_prepend_fence_fstr(pinfo->cinfo, COL_INFO, "[FCP CLEAR_TASK_SET] ");
} }
flags &= (~( 0x04 ));
proto_tree_add_boolean(tree, hf_fcp_mgmt_flags_abort_task_set, tvb, offset, 1, flags);
if (flags & 0x02) { if (flags & 0x02) {
proto_item_append_text(item, " ABORT TASK SET");
col_prepend_fence_fstr(pinfo->cinfo, COL_INFO, "[FCP ABORT_TASK_SET] "); col_prepend_fence_fstr(pinfo->cinfo, COL_INFO, "[FCP ABORT_TASK_SET] ");
} }
flags &= (~( 0x02 ));
if (flags) {
proto_item_append_text(item, " Unknown bitmap value 0x%x", flags);
}
} }
static const true_false_string fcp_rsp_flags_bidi_tfs = { static const true_false_string fcp_rsp_flags_bidi_tfs = {
@ -280,97 +263,40 @@ static void
dissect_rsp_flags(proto_tree *parent_tree, tvbuff_t *tvb, int offset) dissect_rsp_flags(proto_tree *parent_tree, tvbuff_t *tvb, int offset)
{ {
proto_item *item; proto_item *item;
proto_tree *tree;
gboolean bidi_resid_present = FALSE;
guint8 flags; guint8 flags;
static const int * resid_present_flags[] = {
&hf_fcp_rsp_flags_bidi,
&hf_fcp_rsp_flags_bidi_rru,
&hf_fcp_rsp_flags_bidi_rro,
&hf_fcp_rsp_flags_conf_req,
&hf_fcp_rsp_flags_resid_under,
&hf_fcp_rsp_flags_resid_over,
&hf_fcp_rsp_flags_sns_vld,
&hf_fcp_rsp_flags_res_vld,
NULL
};
item = proto_tree_add_item(parent_tree, hf_fcp_rspflags, tvb, offset, 1, ENC_LITTLE_ENDIAN); static const int * no_resid_flags[] = {
tree = proto_item_add_subtree(item, ett_fcp_rsp_flags); &hf_fcp_rsp_flags_bidi,
&hf_fcp_rsp_flags_conf_req,
&hf_fcp_rsp_flags_resid_under,
&hf_fcp_rsp_flags_resid_over,
&hf_fcp_rsp_flags_sns_vld,
&hf_fcp_rsp_flags_res_vld,
NULL
};
flags = tvb_get_guint8(tvb, offset); flags = tvb_get_guint8(tvb, offset);
if (flags & 0x80) {
item = proto_tree_add_bitmask_with_flags(parent_tree, tvb, offset, hf_fcp_rspflags,
ett_fcp_rsp_flags, resid_present_flags, ENC_NA, BMT_NO_FALSE|BMT_NO_TFS);
} else {
item = proto_tree_add_bitmask_with_flags(parent_tree, tvb, offset, hf_fcp_rspflags,
ett_fcp_rsp_flags, no_resid_flags, ENC_NA, BMT_NO_FALSE|BMT_NO_TFS);
}
if (!flags) if (!flags)
proto_item_append_text(item, " (No values set)"); proto_item_append_text(item, " (No values set)");
/* BIDI RSP */
proto_tree_add_boolean(tree, hf_fcp_rsp_flags_bidi, tvb, offset, 1, flags);
if (flags & 0x80) {
bidi_resid_present = TRUE;
proto_item_append_text(item, " BIDI_RSP");
if (flags & (~( 0x80 )))
proto_item_append_text(item, ",");
}
flags &= (~( 0x80 ));
/* these two bits are only defined if the bidi bit is set */
if (bidi_resid_present) {
/* BIDI READ RESID UNDER */
proto_tree_add_boolean(tree, hf_fcp_rsp_flags_bidi_rru, tvb, offset, 1, flags);
if (flags & 0x40) {
proto_item_append_text(item, " BIDI_RRU");
if (flags & (~( 0x40 )))
proto_item_append_text(item, ",");
}
flags &= (~( 0x40 ));
/* BIDI READ RESID OVER */
proto_tree_add_boolean(tree, hf_fcp_rsp_flags_bidi_rro, tvb, offset, 1, flags);
if (flags & 0x20) {
proto_item_append_text(item, " BIDI_RRO");
if (flags & (~( 0x20 )))
proto_item_append_text(item, ",");
}
flags &= (~( 0x20 ));
}
/* Conf Req */
proto_tree_add_boolean(tree, hf_fcp_rsp_flags_conf_req, tvb, offset, 1, flags);
if (flags & 0x10) {
proto_item_append_text(item, " CONF REQ");
if (flags & (~( 0x10 )))
proto_item_append_text(item, ",");
}
flags &= (~( 0x10 ));
/* Resid Under */
proto_tree_add_boolean(tree, hf_fcp_rsp_flags_resid_under, tvb, offset, 1, flags);
if (flags & 0x08) {
proto_item_append_text(item, " RESID UNDER");
if (flags & (~( 0x08 )))
proto_item_append_text(item, ",");
}
flags &= (~( 0x08 ));
/* Resid Over */
proto_tree_add_boolean(tree, hf_fcp_rsp_flags_resid_over, tvb, offset, 1, flags);
if (flags & 0x04) {
proto_item_append_text(item, " RESID OVER");
if (flags & (~( 0x04 )))
proto_item_append_text(item, ",");
}
flags &= (~( 0x04 ));
/* SNS len valid */
proto_tree_add_boolean(tree, hf_fcp_rsp_flags_sns_vld, tvb, offset, 1, flags);
if (flags & 0x02) {
proto_item_append_text(item, " SNS VLD");
if (flags & (~( 0x02 )))
proto_item_append_text(item, ",");
}
flags &= (~( 0x02 ));
/* rsp len valid */
proto_tree_add_boolean(tree, hf_fcp_rsp_flags_res_vld, tvb, offset, 1, flags);
if (flags & 0x01) {
proto_item_append_text(item, " RES VLD");
if (flags & (~( 0x01 )))
proto_item_append_text(item, ",");
}
flags &= (~( 0x01 ));
if (flags) {
proto_item_append_text(item, " Unknown bitmap value 0x%x", flags);
}
} }
static void static void

294
epan/dissectors/packet-fcsb3.c
View File

@ -248,165 +248,77 @@ static const value_string fc_sbccs_dib_lrj_errcode_val[] = {
static void static void
dissect_iui_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint16 flags) dissect_iui_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint16 flags)
{ {
proto_item *item; static const int * iui_flags[] = {
proto_tree *tree; &hf_sbccs_iui_as,
&hf_sbccs_iui_es,
&hf_sbccs_iui_val,
NULL
};
item=proto_tree_add_uint(parent_tree, hf_sbccs_iui, proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_sbccs_iui,
tvb, offset, 1, flags); ett_sbccs_iui, iui_flags, flags, BMT_NO_FALSE|BMT_NO_TFS);
tree=proto_item_add_subtree(item, ett_sbccs_iui);
proto_tree_add_boolean(tree, hf_sbccs_iui_as, tvb, offset, 1, flags);
if (flags & 0x10) {
proto_item_append_text(item, " AS");
}
flags &= (~( 0x10 ));
proto_tree_add_boolean(tree, hf_sbccs_iui_es, tvb, offset, 1, flags);
if (flags & 0x08) {
proto_item_append_text(item, " ES");
}
flags &= (~( 0x08 ));
proto_tree_add_item (tree, hf_sbccs_iui_val, tvb, offset, 1, ENC_BIG_ENDIAN);
proto_item_append_text(item, "%s", val_to_str (flags & 0x7, fc_sbccs_iu_val, "0x%x"));
/*flags &= (~( 0x07 ));*/
} }
static void static void
dissect_linkctlinfo (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint16 flags) dissect_linkctlinfo (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint16 flags)
{ {
proto_item *item; static const int * linkctlinfo_flags[] = {
proto_tree *tree; &hf_sbccs_dib_linkctlinfo_ctcconn,
&hf_sbccs_dib_linkctlinfo_ecrcg,
NULL
};
item=proto_tree_add_uint(parent_tree, hf_sbccs_dib_linkctlinfo, proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_sbccs_dib_linkctlinfo,
tvb, offset, 2, flags); ett_sbccs_dib_linkctlinfo, linkctlinfo_flags, flags, BMT_NO_FALSE|BMT_NO_TFS);
tree=proto_item_add_subtree(item, ett_sbccs_dib_linkctlinfo);
proto_tree_add_boolean(tree, hf_sbccs_dib_linkctlinfo_ctcconn, tvb, offset, 2, flags);
if (flags & 0x80) {
proto_item_append_text(item, " CTC Conn");
}
flags &= (~( 0x80 ));
proto_tree_add_boolean(tree, hf_sbccs_dib_linkctlinfo_ecrcg, tvb, offset, 2, flags);
if (flags & 0x01) {
proto_item_append_text(item, " Enhanced CRC Gen");
}
/*flags &= (~( 0x01 ));*/
} }
static void static void
dissect_dh_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint16 flags) dissect_dh_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint16 flags)
{ {
proto_item *item; static const int * dh_flags[] = {
proto_tree *tree; &hf_sbccs_dhflags_end,
&hf_sbccs_dhflags_chaining,
&hf_sbccs_dhflags_earlyend,
&hf_sbccs_dhflags_nocrc,
NULL
};
item=proto_tree_add_uint(parent_tree, hf_sbccs_dhflags, proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_sbccs_dhflags,
tvb, offset, 1, flags); ett_sbccs_dhflags, dh_flags, flags, BMT_NO_FALSE|BMT_NO_TFS);
tree=proto_item_add_subtree(item, ett_sbccs_dhflags);
proto_tree_add_boolean(tree, hf_sbccs_dhflags_end, tvb, offset, 1, flags);
if (flags & 0x80) {
proto_item_append_text(item, " End");
}
flags &= (~( 0x80 ));
proto_tree_add_boolean(tree, hf_sbccs_dhflags_chaining, tvb, offset, 1, flags);
if (flags & 0x10) {
proto_item_append_text(item, " Chaining");
}
flags &= (~( 0x10 ));
proto_tree_add_boolean(tree, hf_sbccs_dhflags_earlyend, tvb, offset, 1, flags);
if (flags & 0x08) {
proto_item_append_text(item, " Early End");
}
flags &= (~( 0x08 ));
proto_tree_add_boolean(tree, hf_sbccs_dhflags_nocrc, tvb, offset, 1, flags);
if (flags & 0x04) {
proto_item_append_text(item, " No CRC");
}
/*flags &= (~( 0x04 ));*/
} }
static void static void
dissect_ccw_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint8 flags) dissect_ccw_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint8 flags)
{ {
proto_item *item; static const int * ccw_flags[] = {
proto_tree *tree; &hf_sbccs_dib_ccw_flags_cd,
&hf_sbccs_dib_ccw_flags_cc,
&hf_sbccs_dib_ccw_flags_sli,
&hf_sbccs_dib_ccw_flags_crr,
NULL
};
item=proto_tree_add_uint(parent_tree, hf_sbccs_dib_ccw_flags, proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_sbccs_dib_ccw_flags,
tvb, offset, 1, flags); ett_sbccs_dib_ccw_flags, ccw_flags, flags, BMT_NO_FALSE|BMT_NO_TFS);
tree=proto_item_add_subtree(item, ett_sbccs_dib_ccw_flags);
proto_tree_add_boolean(tree, hf_sbccs_dib_ccw_flags_cd, tvb, offset, 1, flags);
if (flags & 0x80) {
proto_item_append_text(item, " CD");
}
flags &= (~( 0x80 ));
proto_tree_add_boolean(tree, hf_sbccs_dib_ccw_flags_cc, tvb, offset, 1, flags);
if (flags & 0x40) {
proto_item_append_text(item, " CC");
}
flags &= (~( 0x40 ));
proto_tree_add_boolean(tree, hf_sbccs_dib_ccw_flags_sli, tvb, offset, 1, flags);
if (flags & 0x20) {
proto_item_append_text(item, " SLI");
}
flags &= (~( 0x20 ));
proto_tree_add_boolean(tree, hf_sbccs_dib_ccw_flags_crr, tvb, offset, 1, flags);
if (flags & 0x08) {
proto_item_append_text(item, " CRR");
}
/*flags &= (~( 0x08 ));*/
} }
static void static void
dissect_cmd_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint8 flags) dissect_cmd_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint8 flags)
{ {
proto_item *item; static const int * cmd_flags[] = {
proto_tree *tree; &hf_sbccs_dib_cmdflags_du,
&hf_sbccs_dib_cmdflags_coc,
&hf_sbccs_dib_cmdflags_syr,
&hf_sbccs_dib_cmdflags_rex,
&hf_sbccs_dib_cmdflags_sss,
NULL
};
item=proto_tree_add_uint(parent_tree, hf_sbccs_dib_cmdflags, proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_sbccs_dib_cmdflags,
tvb, offset, 1, flags); ett_sbccs_dib_cmdflags, cmd_flags, flags, BMT_NO_FALSE|BMT_NO_TFS);
tree=proto_item_add_subtree(item, ett_sbccs_dib_cmdflags);
proto_tree_add_boolean(tree, hf_sbccs_dib_cmdflags_du, tvb, offset, 1, flags);
if (flags & 0x10) {
proto_item_append_text(item, " DU");
}
flags &= (~( 0x10 ));
proto_tree_add_boolean(tree, hf_sbccs_dib_cmdflags_coc, tvb, offset, 1, flags);
if (flags & 0x08) {
proto_item_append_text(item, " COC");
}
flags &= (~( 0x08 ));
proto_tree_add_boolean(tree, hf_sbccs_dib_cmdflags_syr, tvb, offset, 1, flags);
if (flags & 0x04) {
proto_item_append_text(item, " SYR");
}
flags &= (~( 0x04 ));
proto_tree_add_boolean(tree, hf_sbccs_dib_cmdflags_rex, tvb, offset, 1, flags);
if (flags & 0x02) {
proto_item_append_text(item, " REX");
}
flags &= (~( 0x02 ));
proto_tree_add_boolean(tree, hf_sbccs_dib_cmdflags_sss, tvb, offset, 1, flags);
if (flags & 0x01) {
proto_item_append_text(item, " SSS");
}
/*flags &= (~( 0x01 ));*/
} }
static const value_string status_ffc_val[] = { static const value_string status_ffc_val[] = {
@ -420,140 +332,82 @@ static const value_string status_ffc_val[] = {
static void static void
dissect_status_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint8 flags) dissect_status_flags (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint8 flags)
{ {
proto_item *item; static const int * status_flags[] = {
proto_tree *tree; &hf_sbccs_dib_statusflags_ffc,
&hf_sbccs_dib_statusflags_ci,
item=proto_tree_add_uint(parent_tree, hf_sbccs_dib_statusflags, &hf_sbccs_dib_statusflags_cr,
tvb, offset, 1, flags); &hf_sbccs_dib_statusflags_lri,
tree=proto_item_add_subtree(item, ett_sbccs_dib_statusflags); &hf_sbccs_dib_statusflags_rv,
NULL
proto_tree_add_item (tree, hf_sbccs_dib_statusflags_ffc, tvb, offset, 1, ENC_BIG_ENDIAN); };
proto_item_append_text(item, "%s", val_to_str ((flags>>5) & 0x07, status_ffc_val, "Reserved:0x%x"));
flags &= (~( 0xE0 ));
proto_tree_add_boolean(tree, hf_sbccs_dib_statusflags_ci, tvb, offset, 1, flags);
if (flags & 0x10) {
proto_item_append_text(item, " CI");
}
flags &= (~( 0x10 ));
proto_tree_add_boolean(tree, hf_sbccs_dib_statusflags_cr, tvb, offset, 1, flags);
if (flags & 0x04) {
proto_item_append_text(item, " CR");
}
flags &= (~( 0x04 ));
proto_tree_add_boolean(tree, hf_sbccs_dib_statusflags_lri, tvb, offset, 1, flags);
if (flags & 0x02) {
proto_item_append_text(item, " LRI");
}
flags &= (~( 0x02 ));
proto_tree_add_boolean(tree, hf_sbccs_dib_statusflags_rv, tvb, offset, 1, flags);
if (flags & 0x01) {
proto_item_append_text(item, " RV");
}
/*flags &= (~( 0x01 ));*/
proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_sbccs_dib_statusflags,
ett_sbccs_dib_statusflags, status_flags, flags, BMT_NO_FALSE|BMT_NO_TFS);
} }
static void static void
dissect_status (packet_info *pinfo, proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint8 flags) dissect_status (packet_info *pinfo, proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint8 flags)
{ {
proto_item *item; static const int * status_flags[] = {
proto_tree *tree; &hf_sbccs_dib_status_attention,
&hf_sbccs_dib_status_modifier,
&hf_sbccs_dib_status_cue,
&hf_sbccs_dib_status_busy,
&hf_sbccs_dib_status_channelend,
&hf_sbccs_dib_status_deviceend,
&hf_sbccs_dib_status_unit_check,
&hf_sbccs_dib_status_unit_exception,
NULL
};
proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_sbccs_dib_status,
ett_sbccs_dib_status, status_flags, flags, BMT_NO_FALSE|BMT_NO_TFS);
item=proto_tree_add_uint(parent_tree, hf_sbccs_dib_status,
tvb, offset, 1, flags);
tree=proto_item_add_subtree(item, ett_sbccs_dib_status);
proto_tree_add_boolean(tree, hf_sbccs_dib_status_attention, tvb, offset, 1, flags);
if (flags & 0x80) { if (flags & 0x80) {
proto_item_append_text(item, " Attention");
col_append_str(pinfo->cinfo, COL_INFO, " Attention"); col_append_str(pinfo->cinfo, COL_INFO, " Attention");
} }
flags &= (~( 0x80 ));
proto_tree_add_boolean(tree, hf_sbccs_dib_status_modifier, tvb, offset, 1, flags);
if (flags & 0x40) { if (flags & 0x40) {
proto_item_append_text(item, " Status Modifier");
col_append_str(pinfo->cinfo, COL_INFO, " Status Modifier"); col_append_str(pinfo->cinfo, COL_INFO, " Status Modifier");
} }
flags &= (~( 0x40 ));
proto_tree_add_boolean(tree, hf_sbccs_dib_status_cue, tvb, offset, 1, flags);
if (flags & 0x20) { if (flags & 0x20) {
proto_item_append_text(item, " Control-Unit End");
col_append_str(pinfo->cinfo, COL_INFO, " Control-Unit End"); col_append_str(pinfo->cinfo, COL_INFO, " Control-Unit End");
} }
flags &= (~( 0x20 ));
proto_tree_add_boolean(tree, hf_sbccs_dib_status_busy, tvb, offset, 1, flags);
if (flags & 0x10) { if (flags & 0x10) {
proto_item_append_text(item, " Busy");
col_append_str(pinfo->cinfo, COL_INFO, " Busy"); col_append_str(pinfo->cinfo, COL_INFO, " Busy");
} }
flags &= (~( 0x10 ));
proto_tree_add_boolean(tree, hf_sbccs_dib_status_channelend, tvb, offset, 1, flags);
if (flags & 0x08) { if (flags & 0x08) {
proto_item_append_text(item, " Channel End");
col_append_str(pinfo->cinfo, COL_INFO, " Channel End"); col_append_str(pinfo->cinfo, COL_INFO, " Channel End");
} }
flags &= (~( 0x08 ));
proto_tree_add_boolean(tree, hf_sbccs_dib_status_deviceend, tvb, offset, 1, flags);
if (flags & 0x04) { if (flags & 0x04) {
proto_item_append_text(item, " Device End");
col_append_str(pinfo->cinfo, COL_INFO, " Device End"); col_append_str(pinfo->cinfo, COL_INFO, " Device End");
} }
flags &= (~( 0x04 ));
proto_tree_add_boolean(tree, hf_sbccs_dib_status_unit_check, tvb, offset, 1, flags);
if (flags & 0x02) { if (flags & 0x02) {
proto_item_append_text(item, " Unit Check");
col_append_str(pinfo->cinfo, COL_INFO, " Unit Check"); col_append_str(pinfo->cinfo, COL_INFO, " Unit Check");
} }
flags &= (~( 0x02 ));
proto_tree_add_boolean(tree, hf_sbccs_dib_status_unit_exception, tvb, offset, 1, flags);
if (flags & 0x01) { if (flags & 0x01) {
proto_item_append_text(item, " Unit Exception");
col_append_str(pinfo->cinfo, COL_INFO, " Unit Exception"); col_append_str(pinfo->cinfo, COL_INFO, " Unit Exception");
} }
/*flags &= (~( 0x01 ));*/
} }
static void static void
dissect_sel_rst_param (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint32 flags) dissect_sel_rst_param (proto_tree *parent_tree, tvbuff_t *tvb, int offset, guint32 flags)
{ {
proto_item *item; static const int * rst_param_flags[] = {
proto_tree *tree; &hf_sbccs_dib_ctlparam_rc,
&hf_sbccs_dib_ctlparam_ru,
&hf_sbccs_dib_ctlparam_ro,
NULL
};
item=proto_tree_add_uint(parent_tree, hf_sbccs_dib_ctlparam, proto_tree_add_bitmask_value_with_flags(parent_tree, tvb, offset, hf_sbccs_dib_ctlparam,
tvb, offset, 3, flags); ett_sbccs_dib_ctlparam, rst_param_flags, flags, BMT_NO_FALSE|BMT_NO_TFS);
tree=proto_item_add_subtree(item, ett_sbccs_dib_ctlparam);
proto_tree_add_boolean(tree, hf_sbccs_dib_ctlparam_rc, tvb, offset, 3, flags);
if (flags & 0x80) {
proto_item_append_text(item, " RC");
}
flags &= (~( 0x80 ));
proto_tree_add_boolean(tree, hf_sbccs_dib_ctlparam_ru, tvb, offset, 3, flags);
if (flags & 0x10) {
proto_item_append_text(item, " RU");
}
flags &= (~( 0x10 ));
proto_tree_add_boolean(tree, hf_sbccs_dib_ctlparam_ro, tvb, offset, 3, flags);
if (flags & 0x08) {
proto_item_append_text(item, " RO");
}
/*flags &= (~( 0x08 ));*/
} }
static void get_fc_sbccs_conv_data (tvbuff_t *tvb, guint offset, static void get_fc_sbccs_conv_data (tvbuff_t *tvb, guint offset,