← Back to branch summary

~jelmer/wireshark/daily-ppa

« back to all changes in this revision

Viewing changes to epan/dissectors/packet-fcsb3.c

  • Committer: Bazaar Package Importer
  • Author(s): Balint Reczey
  • Date: 2010-11-20 18:41:41 UTC
  • mfrom: (1.1.28 upstream) (42.1.5 experimental)
  • Revision ID: james.westby@ubuntu.com-20101120184141-19e4sxq2kfsdnc9i
Tags: 1.4.2-1
* New upstream release 1.4.2
  - release notes:
    http://www.wireshark.org/docs/relnotes/wireshark-1.4.2.html
  - security fixes
     - Nephi Johnson of BreakingPoint discovered that the LDSS dissector
       could overflow a buffer. (No assigned CVE number.)
     - The ZigBee ZCL dissector could go into an infinite loop.
       (No assigned CVE number.)
* drop 05_fix-display-filter-update-when-changing-profile.patch
  patch since it has been integrated upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
epan/dissectors/packet-fcsb3.c
3
3
 * This decoder is for FC-SB3 version 1.4
4
4
 * Copyright 2003, Dinesh G Dutt <ddutt@cisco.com>
5
5
 *
6
 
 * $Id: packet-fcsb3.c 28412 2009-05-19 17:16:14Z stig $
 
6
 * $Id: packet-fcsb3.c 32410 2010-04-06 21:14:01Z wmeier $
7
7
 *
8
8
 * Wireshark - Network traffic analyzer
9
9
 * By Gerald Combs <gerald@wireshark.org>
34
34
# include "config.h"
35
35
#endif
36
36
 
37
 
#include <stdio.h>
38
37
#include <stdlib.h>
39
 
#include <string.h>
40
38
 
41
39
#ifdef HAVE_SYS_TYPES_H
42
40
# include <sys/types.h>
627
625
        proto_tree_add_boolean(tree, hf_sbccs_dib_status_attention, tvb, offset, 1, flags);
628
626
        if (flags&0x80){
629
627
                proto_item_append_text(item, "  Attention");
630
 
                if (check_col(pinfo->cinfo, COL_INFO)) {
631
 
                        col_append_str(pinfo->cinfo, COL_INFO, "  Attention");
632
 
                }
 
628
                col_append_str(pinfo->cinfo, COL_INFO, "  Attention");
633
629
        }
634
630
        flags&=(~( 0x80 ));
635
631
 
636
632
        proto_tree_add_boolean(tree, hf_sbccs_dib_status_modifier, tvb, offset, 1, flags);
637
633
        if (flags&0x40){
638
634
                proto_item_append_text(item, "  Status Modifier");
639
 
                if (check_col(pinfo->cinfo, COL_INFO)) {
640
 
                        col_append_str(pinfo->cinfo, COL_INFO, "  Status Modifier");
641
 
                }
 
635
                col_append_str(pinfo->cinfo, COL_INFO, "  Status Modifier");
642
636
        }
643
637
        flags&=(~( 0x40 ));
644
638
 
645
639
        proto_tree_add_boolean(tree, hf_sbccs_dib_status_cue, tvb, offset, 1, flags);
646
640
        if (flags&0x20){
647
641
                proto_item_append_text(item, "  Control-Unit End");
648
 
                if (check_col(pinfo->cinfo, COL_INFO)) {
649
 
                        col_append_str(pinfo->cinfo, COL_INFO, "  Control-Unit End");
650
 
                }
 
642
                col_append_str(pinfo->cinfo, COL_INFO, "  Control-Unit End");
651
643
        }
652
644
        flags&=(~( 0x20 ));
653
645
 
654
646
        proto_tree_add_boolean(tree, hf_sbccs_dib_status_busy, tvb, offset, 1, flags);
655
647
        if (flags&0x10){
656
648
                proto_item_append_text(item, "  Busy");
657
 
                if (check_col(pinfo->cinfo, COL_INFO)) {
658
 
                        col_append_str(pinfo->cinfo, COL_INFO, "  Busy");
659
 
                }
 
649
                col_append_str(pinfo->cinfo, COL_INFO, "  Busy");
660
650
        }
661
651
        flags&=(~( 0x10 ));
662
652
 
663
653
        proto_tree_add_boolean(tree, hf_sbccs_dib_status_channelend, tvb, offset, 1, flags);
664
654
        if (flags&0x08){
665
655
                proto_item_append_text(item, "  Channel End");
666
 
                if (check_col(pinfo->cinfo, COL_INFO)) {
667
 
                        col_append_str(pinfo->cinfo, COL_INFO, "  Channel End");
668
 
                }
 
656
                col_append_str(pinfo->cinfo, COL_INFO, "  Channel End");
669
657
        }
670
658
        flags&=(~( 0x08 ));
671
659
 
672
660
        proto_tree_add_boolean(tree, hf_sbccs_dib_status_deviceend, tvb, offset, 1, flags);
673
661
        if (flags&0x04){
674
662
                proto_item_append_text(item, "  Device End");
675
 
                if (check_col(pinfo->cinfo, COL_INFO)) {
676
 
                        col_append_str(pinfo->cinfo, COL_INFO, "  Device End");
677
 
                }
 
663
                col_append_str(pinfo->cinfo, COL_INFO, "  Device End");
678
664
        }
679
665
        flags&=(~( 0x04 ));
680
666
 
681
667
        proto_tree_add_boolean(tree, hf_sbccs_dib_status_unit_check, tvb, offset, 1, flags);
682
668
        if (flags&0x02){
683
669
                proto_item_append_text(item, "  Unit Check");
684
 
                if (check_col(pinfo->cinfo, COL_INFO)) {
685
 
                        col_append_str(pinfo->cinfo, COL_INFO, "  Unit Check");
686
 
                }
 
670
                col_append_str(pinfo->cinfo, COL_INFO, "  Unit Check");
687
671
        }
688
672
        flags&=(~( 0x02 ));
689
673
 
690
674
        proto_tree_add_boolean(tree, hf_sbccs_dib_status_unit_exception, tvb, offset, 1, flags);
691
675
        if (flags&0x01){
692
676
                proto_item_append_text(item, "  Unit Exception");
693
 
                if (check_col(pinfo->cinfo, COL_INFO)) {
694
 
                        col_append_str(pinfo->cinfo, COL_INFO, "  Unit Exception");
695
 
                }
 
677
                col_append_str(pinfo->cinfo, COL_INFO, "  Unit Exception");
696
678
        }
697
679
        flags&=(~( 0x01 ));
698
680
 
882
864
        proto_tree_add_item (tree, hf_sbccs_lrc, tvb, offset+12, 4, 0);
883
865
 
884
866
        if (supp_status_cnt) {
885
 
            next_tvb = tvb_new_subset (tvb, offset+FC_SBCCS_DIB_LRC_HDR_SIZE,
886
 
                                       -1, -1);
 
867
            next_tvb = tvb_new_subset_remaining (tvb, offset+FC_SBCCS_DIB_LRC_HDR_SIZE);
887
868
            call_dissector (data_handle, next_tvb, pinfo, tree);
888
869
        }
889
870
    }
1019
1000
    void* pd_save;
1020
1001
        
1021
1002
    /* Make entries in Protocol column and Info column on summary display */
1022
 
    if (check_col(pinfo->cinfo, COL_PROTOCOL)) 
1023
 
        col_set_str(pinfo->cinfo, COL_PROTOCOL, "FC-SB3");
 
1003
    col_set_str(pinfo->cinfo, COL_PROTOCOL, "FC-SB3");
1024
1004
 
1025
1005
    /* Decode the basic SB3 and IU header and determine type of frame */
1026
1006
    type = get_fc_sbccs_iu_type (tvb, offset);
1088
1068
        dissect_fc_sbccs_dib_link_hdr (tvb, pinfo, dib_tree, offset);
1089
1069
        break;
1090
1070
    default:
1091
 
        next_tvb = tvb_new_subset (tvb, offset, -1, -1);
 
1071
        next_tvb = tvb_new_subset_remaining (tvb, offset);
1092
1072
        call_dissector (data_handle, next_tvb, pinfo, dib_tree);
1093
1073
        break;
1094
1074
    }
1095
1075
 
1096
1076
    if ((get_fc_sbccs_iu_type (tvb, 0) != FC_SBCCS_IU_CTL) &&
1097
1077
        (get_fc_sbccs_iu_type (tvb, 0) != FC_SBCCS_IU_CMD_LINK_CTL))  {
1098
 
        next_tvb = tvb_new_subset (tvb, offset+FC_SBCCS_DIB_LRC_HDR_SIZE,
1099
 
                                   -1, -1);
 
1078
        next_tvb = tvb_new_subset_remaining (tvb, offset+FC_SBCCS_DIB_LRC_HDR_SIZE);
1100
1079
        call_dissector (data_handle, next_tvb, pinfo, tree);
1101
1080
    }
1102
1081
    pinfo->private_data = pd_save;
1115
1094
    static hf_register_info hf[] = {
1116
1095
        { &hf_sbccs_chid,
1117
1096
          {"Channel Image ID", "sbccs.chid", FT_UINT8, BASE_DEC, NULL, 0x0,
1118
 
           "", HFILL}},
 
1097
           NULL, HFILL}},
1119
1098
        { &hf_sbccs_cuid,
1120
1099
          {"Control Unit Image ID", "sbccs.cuid", FT_UINT8, BASE_DEC, NULL,
1121
 
           0x0, "", HFILL}},
 
1100
           0x0, NULL, HFILL}},
1122
1101
        { &hf_sbccs_devaddr,
1123
1102
          {"Device Address", "sbccs.devaddr", FT_UINT16, BASE_DEC, NULL, 0x0,
1124
 
           "", HFILL}},
 
1103
           NULL, HFILL}},
1125
1104
        { &hf_sbccs_iui,
1126
1105
          {"Information Unit Identifier", "sbccs.iui", FT_UINT8, BASE_HEX,
1127
 
           NULL, 0x0, "", HFILL}},
 
1106
           NULL, 0x0, NULL, HFILL}},
1128
1107
        { &hf_sbccs_dhflags,
1129
 
          {"DH Flags", "sbccs.dhflags", FT_UINT8, BASE_HEX, NULL, 0x0, "",
 
1108
          {"DH Flags", "sbccs.dhflags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL,
1130
1109
           HFILL}},
1131
1110
        { &hf_sbccs_ccw,
1132
 
          {"CCW Number", "sbccs.ccw", FT_UINT16, BASE_HEX, NULL, 0x0, "",
 
1111
          {"CCW Number", "sbccs.ccw", FT_UINT16, BASE_HEX, NULL, 0x0, NULL,
1133
1112
           HFILL}},
1134
1113
        { &hf_sbccs_token,
1135
 
          {"Token", "sbccs.token", FT_UINT24, BASE_DEC, NULL, 0x0, "",
 
1114
          {"Token", "sbccs.token", FT_UINT24, BASE_DEC, NULL, 0x0, NULL,
1136
1115
           HFILL}},
1137
1116
        { &hf_sbccs_dib_iucnt,
1138
1117
          {"DIB IU Count", "sbccs.iucnt", FT_UINT8, BASE_DEC, NULL, 0x0,
1139
 
           "", HFILL}},
 
1118
           NULL, HFILL}},
1140
1119
        { &hf_sbccs_dib_datacnt,
1141
1120
          {"DIB Data Byte Count", "sbccs.databytecnt", FT_UINT16, BASE_DEC,
1142
 
           NULL, 0x0, "", HFILL}},
 
1121
           NULL, 0x0, NULL, HFILL}},
1143
1122
        { &hf_sbccs_dib_ccw_cmd,
1144
1123
          {"CCW Command", "sbccs.ccwcmd", FT_UINT8, BASE_HEX,
1145
 
           VALS (fc_sbccs_dib_cmd_val), 0x0, "", HFILL}},
 
1124
           VALS (fc_sbccs_dib_cmd_val), 0x0, NULL, HFILL}},
1146
1125
        { &hf_sbccs_dib_ccw_cnt,
1147
 
          {"CCW Count", "sbccs.ccwcnt", FT_UINT16, BASE_DEC, NULL, 0x0, "",
 
1126
          {"CCW Count", "sbccs.ccwcnt", FT_UINT16, BASE_DEC, NULL, 0x0, NULL,
1148
1127
           HFILL}},
1149
1128
        { &hf_sbccs_dib_ioprio,
1150
1129
          {"I/O Priority", "sbccs.ioprio", FT_UINT8, BASE_DEC, NULL, 0x0,
1151
 
           "", HFILL}},
 
1130
           NULL, HFILL}},
1152
1131
        { &hf_sbccs_dib_status,
1153
 
          {"Status", "sbccs.status", FT_UINT8, BASE_HEX, NULL, 0x0, "",
 
1132
          {"Status", "sbccs.status", FT_UINT8, BASE_HEX, NULL, 0x0, NULL,
1154
1133
           HFILL}},
1155
1134
        { &hf_sbccs_dib_residualcnt,
1156
1135
          {"Residual Count", "sbccs.residualcnt", FT_UINT8, BASE_DEC,
1157
 
           NULL, 0x0, "", HFILL}},
 
1136
           NULL, 0x0, NULL, HFILL}},
1158
1137
        { &hf_sbccs_dib_iupacing,
1159
1138
          {"IU Pacing", "sbccs.iupacing", FT_UINT8, BASE_DEC, NULL, 0x0,
1160
 
           "", HFILL}},
 
1139
           NULL, HFILL}},
1161
1140
        { &hf_sbccs_dib_qtuf,
1162
1141
          {"Queue-Time Unit Factor", "sbccs.qtuf", FT_UINT8, BASE_DEC,
1163
 
           NULL, 0xF0, "", HFILL}},
 
1142
           NULL, 0xF0, NULL, HFILL}},
1164
1143
        { &hf_sbccs_dib_qtu,
1165
1144
          {"Queue-Time Unit", "sbccs.qtu", FT_UINT16, BASE_DEC, NULL, 0xFFF,
1166
 
           "", HFILL}},
 
1145
           NULL, HFILL}},
1167
1146
        { &hf_sbccs_dib_dtuf,
1168
1147
          {"Defer-Time Unit Function", "sbccs.dtuf", FT_UINT8, BASE_DEC,
1169
 
           NULL, 0xF0, "", HFILL}},
 
1148
           NULL, 0xF0, NULL, HFILL}},
1170
1149
        { &hf_sbccs_dib_dtu,
1171
1150
          {"Defer-Time Unit", "sbccs.dtu", FT_UINT16, BASE_DEC, NULL, 0xFFF,
1172
 
           "", HFILL}},
 
1151
           NULL, HFILL}},
1173
1152
        { &hf_sbccs_dib_ctlfn,
1174
1153
          {"Control Function", "sbccs.ctlfn", FT_UINT8, BASE_HEX,
1175
 
           VALS (fc_sbccs_dib_ctl_fn_val), 0x0, "", HFILL}},
 
1154
           VALS (fc_sbccs_dib_ctl_fn_val), 0x0, NULL, HFILL}},
1176
1155
        { &hf_sbccs_dib_linkctlfn,
1177
1156
          {"Link Control Function", "sbccs.linkctlfn", FT_UINT8, BASE_HEX,
1178
 
           VALS (fc_sbccs_dib_link_ctl_fn_val), 0x0, "", HFILL}},
 
1157
           VALS (fc_sbccs_dib_link_ctl_fn_val), 0x0, NULL, HFILL}},
1179
1158
        { &hf_sbccs_dib_ctccntr,
1180
1159
          {"CTC Counter", "sbccs.ctccntr", FT_UINT16, BASE_DEC, NULL, 0x0,
1181
 
           "", HFILL}},
 
1160
           NULL, HFILL}},
1182
1161
        { &hf_sbccs_lrc,
1183
 
          {"LRC", "sbccs.lrc", FT_UINT32, BASE_HEX, NULL, 0x0, "", HFILL}},
 
1162
          {"LRC", "sbccs.lrc", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL}},
1184
1163
        { &hf_sbccs_dev_xcp_code,
1185
1164
          {"Device Level Exception Code", "sbccs.dip.xcpcode", FT_UINT8,
1186
 
           BASE_DEC, VALS (fc_sbccs_dib_dev_xcpcode_val), 0x0, "", HFILL}},
 
1165
           BASE_DEC, VALS (fc_sbccs_dib_dev_xcpcode_val), 0x0, NULL, HFILL}},
1187
1166
        { &hf_sbccs_prg_pth_errcode,
1188
1167
          {"Purge Path Error Code", "sbccs.purgepathcode", FT_UINT8,
1189
 
           BASE_DEC, VALS (fc_sbccs_dib_purge_path_err_val), 0x0, "", HFILL}},
 
1168
           BASE_DEC, VALS (fc_sbccs_dib_purge_path_err_val), 0x0, NULL, HFILL}},
1190
1169
        { &hf_sbccs_prg_rsp_errcode,
1191
1170
          {"Purge Path Response Error Code", "sbccs.purgepathrspcode",
1192
1171
           FT_UINT8, BASE_DEC, VALS (fc_sbccs_dib_purge_path_rsp_err_val),
1193
 
           0x0, "", HFILL}},
 
1172
           0x0, NULL, HFILL}},
1194
1173
        { &hf_sbccs_dib_lprcode,
1195
1174
          {"LPR Reason Code", "sbccs.lprcode", FT_UINT8, BASE_DEC,
1196
 
           VALS (fc_sbccs_dib_lpr_errcode_val), 0xF, "", HFILL}},
 
1175
           VALS (fc_sbccs_dib_lpr_errcode_val), 0xF, NULL, HFILL}},
1197
1176
        { &hf_sbccs_dib_tin_imgid_cnt,
1198
1177
          {"TIN Image ID", "sbccs.tinimageidcnt", FT_UINT8, BASE_DEC, NULL,
1199
 
           0x0, "", HFILL}},
 
1178
           0x0, NULL, HFILL}},
1200
1179
        { &hf_sbccs_dib_lrjcode,
1201
1180
          {"LRJ Reaspn Code", "sbccs.lrjcode", FT_UINT8, BASE_HEX,
1202
 
           VALS (fc_sbccs_dib_lrj_errcode_val), 0x7F, "", HFILL}},
 
1181
           VALS (fc_sbccs_dib_lrj_errcode_val), 0x7F, NULL, HFILL}},
1203
1182
        { &hf_sbccs_iui_as,
1204
1183
          {"AS", "sbccs.iui.as", FT_BOOLEAN, 8,
1205
 
           TFS(&tfs_sbccs_iui_as), 0x10, "", HFILL}},
 
1184
           TFS(&tfs_sbccs_iui_as), 0x10, NULL, HFILL}},
1206
1185
        { &hf_sbccs_iui_es,
1207
1186
          {"ES", "sbccs.iui.es", FT_BOOLEAN, 8,
1208
 
           TFS(&tfs_sbccs_iui_es), 0x08, "", HFILL}},
 
1187
           TFS(&tfs_sbccs_iui_es), 0x08, NULL, HFILL}},
1209
1188
        { &hf_sbccs_iui_val,
1210
1189
          {"Val", "sbccs.iui.val", FT_UINT8, BASE_HEX,
1211
 
           VALS(fc_sbccs_iu_val), 0x07, "", HFILL}},
 
1190
           VALS(fc_sbccs_iu_val), 0x07, NULL, HFILL}},
1212
1191
        { &hf_sbccs_dhflags_end,
1213
1192
          {"End", "sbccs.dhflags.end", FT_BOOLEAN, 8,
1214
 
           TFS(&tfs_sbccs_dhflags_end), 0x80, "", HFILL}},
 
1193
           TFS(&tfs_sbccs_dhflags_end), 0x80, NULL, HFILL}},
1215
1194
        { &hf_sbccs_dhflags_chaining,
1216
1195
          {"Chaining", "sbccs.dhflags.chaining", FT_BOOLEAN, 8,
1217
 
           TFS(&tfs_sbccs_dhflags_chaining), 0x10, "", HFILL}},
 
1196
           TFS(&tfs_sbccs_dhflags_chaining), 0x10, NULL, HFILL}},
1218
1197
        { &hf_sbccs_dhflags_earlyend,
1219
1198
          {"Early End", "sbccs.dhflags.earlyend", FT_BOOLEAN, 8,
1220
 
           TFS(&tfs_sbccs_dhflags_earlyend), 0x08, "", HFILL}},
 
1199
           TFS(&tfs_sbccs_dhflags_earlyend), 0x08, NULL, HFILL}},
1221
1200
        { &hf_sbccs_dhflags_nocrc,
1222
1201
          {"No CRC", "sbccs.dhflags.nocrc", FT_BOOLEAN, 8,
1223
 
           TFS(&tfs_sbccs_dhflags_nocrc), 0x04, "", HFILL}},
 
1202
           TFS(&tfs_sbccs_dhflags_nocrc), 0x04, NULL, HFILL}},
1224
1203
        { &hf_sbccs_dib_ccw_flags,
1225
1204
          {"CCW Control Flags", "sbccs.ccwflags", FT_UINT8, BASE_HEX, NULL,
1226
 
           0x0, "", HFILL}},
 
1205
           0x0, NULL, HFILL}},
1227
1206
        { &hf_sbccs_dib_ccw_flags_cd,
1228
1207
          {"CD", "sbccs.ccwflags.cd", FT_BOOLEAN, 8,
1229
 
           TFS(&tfs_sbccs_ccwflags_cd), 0x80, "", HFILL}},
 
1208
           TFS(&tfs_sbccs_ccwflags_cd), 0x80, NULL, HFILL}},
1230
1209
        { &hf_sbccs_dib_ccw_flags_cc,
1231
1210
          {"CC", "sbccs.ccwflags.cc", FT_BOOLEAN, 8,
1232
 
           TFS(&tfs_sbccs_ccwflags_cc), 0x40, "", HFILL}},
 
1211
           TFS(&tfs_sbccs_ccwflags_cc), 0x40, NULL, HFILL}},
1233
1212
        { &hf_sbccs_dib_ccw_flags_sli,
1234
1213
          {"SLI", "sbccs.ccwflags.sli", FT_BOOLEAN, 8,
1235
 
           TFS(&tfs_sbccs_ccwflags_sli), 0x20, "", HFILL}},
 
1214
           TFS(&tfs_sbccs_ccwflags_sli), 0x20, NULL, HFILL}},
1236
1215
        { &hf_sbccs_dib_ccw_flags_crr,
1237
1216
          {"CRR", "sbccs.ccwflags.crr", FT_BOOLEAN, 8,
1238
 
           TFS(&tfs_sbccs_ccwflags_crr), 0x08, "", HFILL}},
 
1217
           TFS(&tfs_sbccs_ccwflags_crr), 0x08, NULL, HFILL}},
1239
1218
        { &hf_sbccs_dib_cmdflags,
1240
1219
          {"Command Flags", "sbccs.cmdflags", FT_UINT8, BASE_HEX, NULL, 0x0,
1241
 
           "", HFILL}},
 
1220
           NULL, HFILL}},
1242
1221
        { &hf_sbccs_dib_cmdflags_du,
1243
1222
          {"DU", "sbccs.cmdflags.du", FT_BOOLEAN, 8,
1244
 
           TFS(&tfs_sbccs_cmdflags_du), 0x10, "", HFILL}},
 
1223
           TFS(&tfs_sbccs_cmdflags_du), 0x10, NULL, HFILL}},
1245
1224
        { &hf_sbccs_dib_cmdflags_coc,
1246
1225
          {"COC", "sbccs.cmdflags.coc", FT_BOOLEAN, 8,
1247
 
           TFS(&tfs_sbccs_cmdflags_coc), 0x08, "", HFILL}},
 
1226
           TFS(&tfs_sbccs_cmdflags_coc), 0x08, NULL, HFILL}},
1248
1227
        { &hf_sbccs_dib_cmdflags_syr,
1249
1228
          {"SYR", "sbccs.cmdflags.syr", FT_BOOLEAN, 8,
1250
 
           TFS(&tfs_sbccs_cmdflags_syr), 0x04, "", HFILL}},
 
1229
           TFS(&tfs_sbccs_cmdflags_syr), 0x04, NULL, HFILL}},
1251
1230
        { &hf_sbccs_dib_cmdflags_rex,
1252
1231
          {"REX", "sbccs.cmdflags.rex", FT_BOOLEAN, 8,
1253
 
           TFS(&tfs_sbccs_cmdflags_rex), 0x02, "", HFILL}},
 
1232
           TFS(&tfs_sbccs_cmdflags_rex), 0x02, NULL, HFILL}},
1254
1233
        { &hf_sbccs_dib_cmdflags_sss,
1255
1234
          {"SSS", "sbccs.cmdflags.sss", FT_BOOLEAN, 8,
1256
 
           TFS(&tfs_sbccs_cmdflags_sss), 0x01, "", HFILL}},
 
1235
           TFS(&tfs_sbccs_cmdflags_sss), 0x01, NULL, HFILL}},
1257
1236
        { &hf_sbccs_dib_statusflags,
1258
1237
          {"Status Flags", "sbccs.statusflags", FT_UINT8, BASE_HEX,
1259
 
           NULL, 0, "", HFILL}},
 
1238
           NULL, 0, NULL, HFILL}},
1260
1239
        { &hf_sbccs_dib_statusflags_ffc,
1261
1240
          {"FFC", "sbccs.statusflags.ffc", FT_UINT8, BASE_HEX,
1262
 
           VALS(status_ffc_val), 0xE0, "", HFILL}},
 
1241
           VALS(status_ffc_val), 0xE0, NULL, HFILL}},
1263
1242
        { &hf_sbccs_dib_statusflags_ci,
1264
1243
          {"CI", "sbccs.statusflags.ci", FT_BOOLEAN, 8,
1265
 
           TFS(&tfs_sbccs_statusflags_ci), 0x10, "", HFILL}},
 
1244
           TFS(&tfs_sbccs_statusflags_ci), 0x10, NULL, HFILL}},
1266
1245
        { &hf_sbccs_dib_statusflags_cr,
1267
1246
          {"CR", "sbccs.statusflags.cr", FT_BOOLEAN, 8,
1268
 
           TFS(&tfs_sbccs_statusflags_cr), 0x04, "", HFILL}},
 
1247
           TFS(&tfs_sbccs_statusflags_cr), 0x04, NULL, HFILL}},
1269
1248
        { &hf_sbccs_dib_statusflags_lri,
1270
1249
          {"LRI", "sbccs.statusflags.lri", FT_BOOLEAN, 8,
1271
 
           TFS(&tfs_sbccs_statusflags_lri), 0x02, "", HFILL}},
 
1250
           TFS(&tfs_sbccs_statusflags_lri), 0x02, NULL, HFILL}},
1272
1251
        { &hf_sbccs_dib_statusflags_rv,
1273
1252
          {"RV", "sbccs.statusflags.rv", FT_BOOLEAN, 8,
1274
 
           TFS(&tfs_sbccs_statusflags_rv), 0x01, "", HFILL}},
 
1253
           TFS(&tfs_sbccs_statusflags_rv), 0x01, NULL, HFILL}},
1275
1254
        { &hf_sbccs_dib_status_attention,
1276
1255
          {"Attention", "sbccs.status.attention", FT_BOOLEAN, 8,
1277
 
           TFS(&tfs_sbccs_status_attention), 0x80, "", HFILL}},
 
1256
           TFS(&tfs_sbccs_status_attention), 0x80, NULL, HFILL}},
1278
1257
        { &hf_sbccs_dib_status_modifier,
1279
1258
          {"Status Modifier", "sbccs.status.modifier", FT_BOOLEAN, 8,
1280
 
           TFS(&tfs_sbccs_status_modifier), 0x40, "", HFILL}},
 
1259
           TFS(&tfs_sbccs_status_modifier), 0x40, NULL, HFILL}},
1281
1260
        { &hf_sbccs_dib_status_cue,
1282
1261
          {"Control-Unit End", "sbccs.status.cue", FT_BOOLEAN, 8,
1283
 
           TFS(&tfs_sbccs_status_cue), 0x20, "", HFILL}},
 
1262
           TFS(&tfs_sbccs_status_cue), 0x20, NULL, HFILL}},
1284
1263
        { &hf_sbccs_dib_status_busy,
1285
1264
          {"Busy", "sbccs.status.busy", FT_BOOLEAN, 8,
1286
 
           TFS(&tfs_sbccs_status_busy), 0x10, "", HFILL}},
 
1265
           TFS(&tfs_sbccs_status_busy), 0x10, NULL, HFILL}},
1287
1266
        { &hf_sbccs_dib_status_channelend,
1288
1267
          {"Channel End", "sbccs.status.channel_end", FT_BOOLEAN, 8,
1289
 
           TFS(&tfs_sbccs_status_channelend), 0x08, "", HFILL}},
 
1268
           TFS(&tfs_sbccs_status_channelend), 0x08, NULL, HFILL}},
1290
1269
        { &hf_sbccs_dib_status_deviceend,
1291
1270
          {"Device End", "sbccs.status.device_end", FT_BOOLEAN, 8,
1292
 
           TFS(&tfs_sbccs_status_deviceend), 0x04, "", HFILL}},
 
1271
           TFS(&tfs_sbccs_status_deviceend), 0x04, NULL, HFILL}},
1293
1272
        { &hf_sbccs_dib_status_unit_check,
1294
1273
          {"Unit Check", "sbccs.status.unit_check", FT_BOOLEAN, 8,
1295
 
           TFS(&tfs_sbccs_status_unitcheck), 0x02, "", HFILL}},
 
1274
           TFS(&tfs_sbccs_status_unitcheck), 0x02, NULL, HFILL}},
1296
1275
        { &hf_sbccs_dib_status_unit_exception,
1297
1276
          {"Unit Exception", "sbccs.status.unitexception", FT_BOOLEAN, 8,
1298
 
           TFS(&tfs_sbccs_status_unitexception), 0x01, "", HFILL}},
 
1277
           TFS(&tfs_sbccs_status_unitexception), 0x01, NULL, HFILL}},
1299
1278
        { &hf_sbccs_dib_ctlparam,
1300
1279
          {"Control Parameters", "sbccs.ctlparam", FT_UINT24, BASE_HEX,
1301
 
           NULL, 0x0, "", HFILL}},
 
1280
           NULL, 0x0, NULL, HFILL}},
1302
1281
        { &hf_sbccs_dib_ctlparam_rc,
1303
1282
          {"RC", "sbccs.ctlparam.rc", FT_BOOLEAN, 24,
1304
 
           TFS(&tfs_sbccs_ctlparam_rc), 0x80, "", HFILL}},
 
1283
           TFS(&tfs_sbccs_ctlparam_rc), 0x80, NULL, HFILL}},
1305
1284
        { &hf_sbccs_dib_ctlparam_ru,
1306
1285
          {"RU", "sbccs.ctlparam.ru", FT_BOOLEAN, 24,
1307
 
           TFS(&tfs_sbccs_ctlparam_ru), 0x10, "", HFILL}},
 
1286
           TFS(&tfs_sbccs_ctlparam_ru), 0x10, NULL, HFILL}},
1308
1287
        { &hf_sbccs_dib_ctlparam_ro,
1309
1288
          {"RO", "sbccs.ctlparam.ro", FT_BOOLEAN, 24,
1310
 
           TFS(&tfs_sbccs_ctlparam_ro), 0x08, "", HFILL}},
 
1289
           TFS(&tfs_sbccs_ctlparam_ro), 0x08, NULL, HFILL}},
1311
1290
        { &hf_sbccs_dib_linkctlinfo,
1312
1291
          {"Link Control Information", "sbccs.linkctlinfo", FT_UINT16,
1313
 
           BASE_HEX, NULL, 0x0, "", HFILL}},
 
1292
           BASE_HEX, NULL, 0x0, NULL, HFILL}},
1314
1293
        { &hf_sbccs_dib_linkctlinfo_ctcconn,
1315
1294
          {"CTC Conn", "sbccs.linkctlinfo.ctc_conn", FT_BOOLEAN, 16,
1316
 
           TFS(&tfs_sbccs_linkctlinfo_ctcconn), 0x80, "", HFILL}},
 
1295
           TFS(&tfs_sbccs_linkctlinfo_ctcconn), 0x80, NULL, HFILL}},
1317
1296
        { &hf_sbccs_dib_linkctlinfo_ecrcg,
1318
1297
          {"Enhanced CRC Generation", "sbccs.linkctlinfo.ecrcg", FT_BOOLEAN, 16,
1319
 
           TFS(&tfs_sbccs_linkctlinfo_ecrcg), 0x01, "", HFILL}},
 
1298
           TFS(&tfs_sbccs_linkctlinfo_ecrcg), 0x01, NULL, HFILL}},
1320
1299
    };
1321
1300
 
1322
1301