diff --git a/epan/dissectors/packet-fcsb3.c b/epan/dissectors/packet-fcsb3.c
index b0e1f40380..7bb7a84a83 100644
--- a/epan/dissectors/packet-fcsb3.c
+++ b/epan/dissectors/packet-fcsb3.c
@@ -1077,342 +1077,342 @@ proto_register_fcsbccs (void)
     /* Setup list of header fields  See Section 1.6.1 for details*/
     static hf_register_info hf[] = {
         { &hf_sbccs_chid,
-          { "Channel Image ID", "sbccs.chid",
+          { "Channel Image ID", "fcsb3.chid",
             FT_UINT8, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_cuid,
-          { "Control Unit Image ID", "sbccs.cuid",
+          { "Control Unit Image ID", "fcsb3.cuid",
             FT_UINT8, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_devaddr,
-          { "Device Address", "sbccs.devaddr",
+          { "Device Address", "fcsb3.devaddr",
             FT_UINT16, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_iui,
-          { "Information Unit Identifier", "sbccs.iui",
+          { "Information Unit Identifier", "fcsb3.iui",
             FT_UINT8, BASE_HEX, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dhflags,
-          { "DH Flags", "sbccs.dhflags",
+          { "DH Flags", "fcsb3.dhflags",
             FT_UINT8, BASE_HEX, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_ccw,
-          { "CCW Number", "sbccs.ccw",
+          { "CCW Number", "fcsb3.ccw",
             FT_UINT16, BASE_HEX, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_token,
-          { "Token", "sbccs.token",
+          { "Token", "fcsb3.token",
             FT_UINT24, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_iucnt,
-          { "DIB IU Count", "sbccs.iucnt",
+          { "DIB IU Count", "fcsb3.iucnt",
             FT_UINT8, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_datacnt,
-          { "DIB Data Byte Count", "sbccs.databytecnt",
+          { "DIB Data Byte Count", "fcsb3.databytecnt",
             FT_UINT16, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ccw_cmd,
-          { "CCW Command", "sbccs.ccwcmd",
+          { "CCW Command", "fcsb3.ccwcmd",
             FT_UINT8, BASE_HEX, VALS (fc_sbccs_dib_cmd_val), 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ccw_cnt,
-          { "CCW Count", "sbccs.ccwcnt",
+          { "CCW Count", "fcsb3.ccwcnt",
             FT_UINT16, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ioprio,
-          { "I/O Priority", "sbccs.ioprio",
+          { "I/O Priority", "fcsb3.ioprio",
             FT_UINT8, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_status,
-          { "Status", "sbccs.status",
+          { "Status", "fcsb3.status",
             FT_UINT8, BASE_HEX, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_residualcnt,
-          { "Residual Count", "sbccs.residualcnt",
+          { "Residual Count", "fcsb3.residualcnt",
             FT_UINT8, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_iupacing,
-          { "IU Pacing", "sbccs.iupacing",
+          { "IU Pacing", "fcsb3.iupacing",
             FT_UINT8, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_qtuf,
-          { "Queue-Time Unit Factor", "sbccs.qtuf",
+          { "Queue-Time Unit Factor", "fcsb3.qtuf",
             FT_UINT8, BASE_DEC, NULL, 0xF0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_qtu,
-          { "Queue-Time Unit", "sbccs.qtu",
+          { "Queue-Time Unit", "fcsb3.qtu",
             FT_UINT16, BASE_DEC, NULL, 0xFFF,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_dtuf,
-          { "Defer-Time Unit Function", "sbccs.dtuf",
+          { "Defer-Time Unit Function", "fcsb3.dtuf",
             FT_UINT8, BASE_DEC, NULL, 0xF0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_dtu,
-          { "Defer-Time Unit", "sbccs.dtu",
+          { "Defer-Time Unit", "fcsb3.dtu",
             FT_UINT16, BASE_DEC, NULL, 0xFFF,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ctlfn,
-          { "Control Function", "sbccs.ctlfn",
+          { "Control Function", "fcsb3.ctlfn",
             FT_UINT8, BASE_HEX, VALS (fc_sbccs_dib_ctl_fn_val), 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_linkctlfn,
-          { "Link Control Function", "sbccs.linkctlfn",
+          { "Link Control Function", "fcsb3.linkctlfn",
             FT_UINT8, BASE_HEX, VALS (fc_sbccs_dib_link_ctl_fn_val), 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ctccntr,
-          { "CTC Counter", "sbccs.ctccntr",
+          { "CTC Counter", "fcsb3.ctccntr",
             FT_UINT16, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_lrc,
-          { "LRC", "sbccs.lrc",
+          { "LRC", "fcsb3.lrc",
             FT_UINT32, BASE_HEX, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dev_xcp_code,
-          { "Device Level Exception Code", "sbccs.dip.xcpcode",
+          { "Device Level Exception Code", "fcsb3.dip.xcpcode",
             FT_UINT8, BASE_DEC, VALS (fc_sbccs_dib_dev_xcpcode_val), 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_prg_pth_errcode,
-          { "Purge Path Error Code", "sbccs.purgepathcode",
+          { "Purge Path Error Code", "fcsb3.purgepathcode",
             FT_UINT8, BASE_DEC, VALS (fc_sbccs_dib_purge_path_err_val), 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_prg_rsp_errcode,
-          { "Purge Path Response Error Code", "sbccs.purgepathrspcode",
+          { "Purge Path Response Error Code", "fcsb3.purgepathrspcode",
             FT_UINT8, BASE_DEC, VALS (fc_sbccs_dib_purge_path_rsp_err_val), 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_lprcode,
-          { "LPR Reason Code", "sbccs.lprcode",
+          { "LPR Reason Code", "fcsb3.lprcode",
             FT_UINT8, BASE_DEC, VALS (fc_sbccs_dib_lpr_errcode_val), 0xF,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_tin_imgid_cnt,
-          { "TIN Image ID", "sbccs.tinimageidcnt",
+          { "TIN Image ID", "fcsb3.tinimageidcnt",
             FT_UINT8, BASE_DEC, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_lrjcode,
-          { "LRJ Reaspn Code", "sbccs.lrjcode",
+          { "LRJ Reaspn Code", "fcsb3.lrjcode",
             FT_UINT8, BASE_HEX, VALS (fc_sbccs_dib_lrj_errcode_val), 0x7F,
             NULL, HFILL}},
 
         { &hf_sbccs_iui_as,
-          { "AS", "sbccs.iui.as",
+          { "AS", "fcsb3.iui.as",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_iui_as), 0x10,
             NULL, HFILL}},
 
         { &hf_sbccs_iui_es,
-          { "ES", "sbccs.iui.es",
+          { "ES", "fcsb3.iui.es",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_iui_es), 0x08,
             NULL, HFILL}},
 
         { &hf_sbccs_iui_val,
-          { "Val", "sbccs.iui.val",
+          { "Val", "fcsb3.iui.val",
             FT_UINT8, BASE_HEX, VALS(fc_sbccs_iu_val), 0x07,
             NULL, HFILL}},
 
         { &hf_sbccs_dhflags_end,
-          { "End", "sbccs.dhflags.end",
+          { "End", "fcsb3.dhflags.end",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_dhflags_end), 0x80,
             NULL, HFILL}},
 
         { &hf_sbccs_dhflags_chaining,
-          { "Chaining", "sbccs.dhflags.chaining",
+          { "Chaining", "fcsb3.dhflags.chaining",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_dhflags_chaining), 0x10,
             NULL, HFILL}},
 
         { &hf_sbccs_dhflags_earlyend,
-          { "Early End", "sbccs.dhflags.earlyend",
+          { "Early End", "fcsb3.dhflags.earlyend",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_dhflags_earlyend), 0x08,
             NULL, HFILL}},
 
         { &hf_sbccs_dhflags_nocrc,
-          { "No CRC", "sbccs.dhflags.nocrc",
+          { "No CRC", "fcsb3.dhflags.nocrc",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_dhflags_nocrc), 0x04,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ccw_flags,
-          { "CCW Control Flags", "sbccs.ccwflags",
+          { "CCW Control Flags", "fcsb3.ccwflags",
             FT_UINT8, BASE_HEX, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ccw_flags_cd,
-          { "CD", "sbccs.ccwflags.cd",
+          { "CD", "fcsb3.ccwflags.cd",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_ccwflags_cd), 0x80,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ccw_flags_cc,
-          { "CC", "sbccs.ccwflags.cc",
+          { "CC", "fcsb3.ccwflags.cc",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_ccwflags_cc), 0x40,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ccw_flags_sli,
-          { "SLI", "sbccs.ccwflags.sli",
+          { "SLI", "fcsb3.ccwflags.sli",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_ccwflags_sli), 0x20,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ccw_flags_crr,
-          { "CRR", "sbccs.ccwflags.crr",
+          { "CRR", "fcsb3.ccwflags.crr",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_ccwflags_crr), 0x08,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_cmdflags,
-          { "Command Flags", "sbccs.cmdflags",
+          { "Command Flags", "fcsb3.cmdflags",
             FT_UINT8, BASE_HEX, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_cmdflags_du,
-          { "DU", "sbccs.cmdflags.du",
+          { "DU", "fcsb3.cmdflags.du",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_cmdflags_du), 0x10,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_cmdflags_coc,
-          { "COC", "sbccs.cmdflags.coc",
+          { "COC", "fcsb3.cmdflags.coc",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_cmdflags_coc), 0x08,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_cmdflags_syr,
-          { "SYR", "sbccs.cmdflags.syr",
+          { "SYR", "fcsb3.cmdflags.syr",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_cmdflags_syr), 0x04,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_cmdflags_rex,
-          { "REX", "sbccs.cmdflags.rex",
+          { "REX", "fcsb3.cmdflags.rex",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_cmdflags_rex), 0x02,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_cmdflags_sss,
-          { "SSS", "sbccs.cmdflags.sss",
+          { "SSS", "fcsb3.cmdflags.sss",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_cmdflags_sss), 0x01,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_statusflags,
-          { "Status Flags", "sbccs.statusflags",
+          { "Status Flags", "fcsb3.statusflags",
             FT_UINT8, BASE_HEX, NULL, 0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_statusflags_ffc,
-          { "FFC", "sbccs.statusflags.ffc",
+          { "FFC", "fcsb3.statusflags.ffc",
             FT_UINT8, BASE_HEX, VALS(status_ffc_val), 0xE0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_statusflags_ci,
-          { "CI", "sbccs.statusflags.ci",
+          { "CI", "fcsb3.statusflags.ci",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_statusflags_ci), 0x10,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_statusflags_cr,
-          { "CR", "sbccs.statusflags.cr",
+          { "CR", "fcsb3.statusflags.cr",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_statusflags_cr), 0x04,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_statusflags_lri,
-          { "LRI", "sbccs.statusflags.lri",
+          { "LRI", "fcsb3.statusflags.lri",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_statusflags_lri), 0x02,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_statusflags_rv,
-          { "RV", "sbccs.statusflags.rv",
+          { "RV", "fcsb3.statusflags.rv",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_statusflags_rv), 0x01,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_status_attention,
-          { "Attention", "sbccs.status.attention",
+          { "Attention", "fcsb3.status.attention",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_status_attention), 0x80,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_status_modifier,
-          { "Status Modifier", "sbccs.status.modifier",
+          { "Status Modifier", "fcsb3.status.modifier",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_status_modifier), 0x40,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_status_cue,
-          { "Control-Unit End", "sbccs.status.cue",
+          { "Control-Unit End", "fcsb3.status.cue",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_status_cue), 0x20,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_status_busy,
-          { "Busy", "sbccs.status.busy",
+          { "Busy", "fcsb3.status.busy",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_status_busy), 0x10,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_status_channelend,
-          { "Channel End", "sbccs.status.channel_end",
+          { "Channel End", "fcsb3.status.channel_end",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_status_channelend), 0x08,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_status_deviceend,
-          { "Device End", "sbccs.status.device_end",
+          { "Device End", "fcsb3.status.device_end",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_status_deviceend), 0x04,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_status_unit_check,
-          { "Unit Check", "sbccs.status.unit_check",
+          { "Unit Check", "fcsb3.status.unit_check",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_status_unitcheck), 0x02,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_status_unit_exception,
-          { "Unit Exception", "sbccs.status.unitexception",
+          { "Unit Exception", "fcsb3.status.unitexception",
             FT_BOOLEAN, 8, TFS(&tfs_sbccs_status_unitexception), 0x01,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ctlparam,
-          { "Control Parameters", "sbccs.ctlparam",
+          { "Control Parameters", "fcsb3.ctlparam",
             FT_UINT24, BASE_HEX, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ctlparam_rc,
-          { "RC", "sbccs.ctlparam.rc",
+          { "RC", "fcsb3.ctlparam.rc",
             FT_BOOLEAN, 24, TFS(&tfs_sbccs_ctlparam_rc), 0x80,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ctlparam_ru,
-          { "RU", "sbccs.ctlparam.ru",
+          { "RU", "fcsb3.ctlparam.ru",
             FT_BOOLEAN, 24, TFS(&tfs_sbccs_ctlparam_ru), 0x10,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_ctlparam_ro,
-          { "RO", "sbccs.ctlparam.ro",
+          { "RO", "fcsb3.ctlparam.ro",
             FT_BOOLEAN, 24, TFS(&tfs_sbccs_ctlparam_ro), 0x08,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_linkctlinfo,
-          { "Link Control Information", "sbccs.linkctlinfo",
+          { "Link Control Information", "fcsb3.linkctlinfo",
             FT_UINT16, BASE_HEX, NULL, 0x0,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_linkctlinfo_ctcconn,
-          { "CTC Conn", "sbccs.linkctlinfo.ctc_conn",
+          { "CTC Conn", "fcsb3.linkctlinfo.ctc_conn",
             FT_BOOLEAN, 16, TFS(&tfs_sbccs_linkctlinfo_ctcconn), 0x80,
             NULL, HFILL}},
 
         { &hf_sbccs_dib_linkctlinfo_ecrcg,
-          { "Enhanced CRC Generation", "sbccs.linkctlinfo.ecrcg",
+          { "Enhanced CRC Generation", "fcsb3.linkctlinfo.ecrcg",
             FT_BOOLEAN, 16, TFS(&tfs_sbccs_linkctlinfo_ecrcg), 0x01,
             NULL, HFILL}},
     };
@@ -1433,7 +1433,7 @@ proto_register_fcsbccs (void)
 
     /* Register the protocol name and description */
     proto_fc_sbccs = proto_register_protocol ("Fibre Channel Single Byte Command",
-                                              "FC-SB3", "sb3");
+                                              "FC-SB3", "fcsb3");
 
     proto_register_field_array(proto_fc_sbccs, hf, array_length(hf));
     proto_register_subtree_array(ett, array_length(ett));
diff --git a/epan/dissectors/packet-h263p.c b/epan/dissectors/packet-h263p.c
index 8ff839861f..c3583b129f 100644
--- a/epan/dissectors/packet-h263p.c
+++ b/epan/dissectors/packet-h263p.c
@@ -236,7 +236,7 @@ proto_register_h263P(void)
 			&hf_h263P_payload,
 			{
 				"H.263 RFC4629 payload",
-				"h263P.payload",
+				"h263p.payload",
 				FT_NONE,
 				BASE_NONE,
 				NULL,
@@ -248,7 +248,7 @@ proto_register_h263P(void)
 			&hf_h263P_rr,
 			{
 				"Reserved",
-				"h263P.rr",
+				"h263p.rr",
 				FT_UINT16,
 				BASE_DEC,
 				NULL,
@@ -260,7 +260,7 @@ proto_register_h263P(void)
 			&hf_h263P_pbit,
 			{
 				"P",
-				"h263P.p",
+				"h263p.p",
 				FT_BOOLEAN,
 				16,
 				NULL,
@@ -272,7 +272,7 @@ proto_register_h263P(void)
 			&hf_h263P_vbit,
 			{
 				"V",
-				"h263P.v",
+				"h263p.v",
 				FT_BOOLEAN,
 				16,
 				NULL,
@@ -284,7 +284,7 @@ proto_register_h263P(void)
 			&hf_h263P_plen,
 			{
 				"PLEN",
-				"h263P.plen",
+				"h263p.plen",
 				FT_UINT16,
 				BASE_DEC,
 				NULL,
@@ -296,7 +296,7 @@ proto_register_h263P(void)
 			&hf_h263P_pebit,
 			{
 				"PEBIT",
-				"h263P.pebit",
+				"h263p.pebit",
 				FT_UINT16,
 				BASE_DEC,
 				NULL,
@@ -310,7 +310,7 @@ proto_register_h263P(void)
 			&hf_h263P_tid,
 			{
 				"Thread ID",
-				"h263P.tid",
+				"h263p.tid",
 				FT_UINT8,
 				BASE_DEC,
 				NULL,
@@ -322,7 +322,7 @@ proto_register_h263P(void)
 			&hf_h263P_trun,
 			{
 				"Trun",
-				"h263P.trun",
+				"h263p.trun",
 				FT_UINT8,
 				BASE_DEC,
 				NULL,
@@ -334,7 +334,7 @@ proto_register_h263P(void)
 			&hf_h263P_s,
 			{
 				"S",
-				"h263P.s",
+				"h263p.s",
 				FT_UINT8,
 				BASE_DEC,
 				NULL,
@@ -346,7 +346,7 @@ proto_register_h263P(void)
 			&hf_h263P_extra_hdr,
 			{
 				"Extra picture header",
-				"h263P.extra_hdr",
+				"h263p.extra_hdr",
 				FT_BYTES,
 				BASE_NONE,
 				NULL,
@@ -358,7 +358,7 @@ proto_register_h263P(void)
 			&hf_h263P_PSC,
 			{
 				"H.263 PSC",
-				"h263P.PSC",
+				"h263p.PSC",
 				FT_UINT16,
 				BASE_HEX,
 				NULL,
@@ -370,7 +370,7 @@ proto_register_h263P(void)
 			&hf_h263P_TR,
 			{
 				"H.263 Temporal Reference",
-				"h263P.tr",
+				"h263p.tr",
 				FT_UINT16,
 				BASE_HEX,
 				NULL,
diff --git a/epan/dissectors/packet-infiniband_sdp.c b/epan/dissectors/packet-infiniband_sdp.c
index 8ae477ac49..b1c9419b03 100644
--- a/epan/dissectors/packet-infiniband_sdp.c
+++ b/epan/dissectors/packet-infiniband_sdp.c
@@ -336,146 +336,146 @@ proto_register_ib_sdp(void)
     module_t *ib_sdp_module;
     static hf_register_info hf[] = {
         { &hf_ib_sdp, {
-            "SDP", "infiniband.sdp",
+            "SDP", "infiniband_sdp",
             FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL}
         },
         /* SDP BSDH Header */
         { &hf_ib_sdp_bsdh, {
-            "BSDH", "infiniband.sdp.bsdh",
+            "BSDH", "infiniband_sdp.bsdh",
             FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL}
         },
         { &hf_ib_sdp_mid, {
-            "MID", "infiniband.sdp.bsdh.mid",
+            "MID", "infiniband_sdp.bsdh.mid",
             FT_UINT8, BASE_HEX|BASE_RANGE_STRING, RVALS(mid_meanings), 0x0, NULL, HFILL}
         },
         {&hf_ib_sdp_flags, {
-            "Flags", "infiniband.sdp.bsdh.flags",
+            "Flags", "infiniband_sdp.bsdh.flags",
             FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}
         },
         {&hf_ib_sdp_flags_oobpres, {
-            "OOB_PRES", "infiniband.sdp.bsdh.oobpres",
+            "OOB_PRES", "infiniband_sdp.bsdh.oobpres",
             FT_UINT8, BASE_HEX, NULL, 0x1, "Out-Of-Band Data is present", HFILL}
         },
         {&hf_ib_sdp_flags_oob_pend, {
-            "OOB_PEND", "infiniband.sdp.bsdh.oobpend",
+            "OOB_PEND", "infiniband_sdp.bsdh.oobpend",
             FT_UINT8, BASE_HEX, NULL, 0x2, "Out-Of-Band Data is pending", HFILL}
         },
         {&hf_ib_sdp_flags_reqpipe, {
-            "REQ_PIPE", "infiniband.sdp.bsdh.reqpipe",
+            "REQ_PIPE", "infiniband_sdp.bsdh.reqpipe",
             FT_UINT8, BASE_HEX, NULL, 0x4, "Request change to Pipelined Mode", HFILL}
         },
         {&hf_ib_sdp_bufs, {
-            "Buffers", "infiniband.sdp.bsdh.bufs",
+            "Buffers", "infiniband_sdp.bsdh.bufs",
             FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL}
         },
         {&hf_ib_sdp_len, {
-            "Length", "infiniband.sdp.bsdh.len",
+            "Length", "infiniband_sdp.bsdh.len",
             FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL}
         },
         {&hf_ib_sdp_mseq, {
-            "MSeq", "infiniband.sdp.bsdh.mseq",
+            "MSeq", "infiniband_sdp.bsdh.mseq",
             FT_UINT32, BASE_HEX, NULL, 0x0, "Message Sequence Number", HFILL}
         },
         {&hf_ib_sdp_mseqack, {
-            "MSeqAck", "infiniband.sdp.bsdh.mseqack",
+            "MSeqAck", "infiniband_sdp.bsdh.mseqack",
             FT_UINT32, BASE_HEX, NULL, 0x0, "Message Sequence Number Acknowledgement", HFILL}
         },
         /* SDP Hello Header */
         {&hf_ib_sdp_hh, {
-            "Hello Header", "infiniband.sdp.hh",
+            "Hello Header", "infiniband_sdp.hh",
             FT_NONE, BASE_NONE, NULL, 0x00, NULL, HFILL}
         },
         {&hf_ib_sdp_majv, {
-            "Major Protocol Version Number", "infiniband.sdp.hh.majv",
+            "Major Protocol Version Number", "infiniband_sdp.hh.majv",
             FT_UINT8, BASE_HEX, NULL, 0xf0, NULL, HFILL}
         },
         {&hf_ib_sdp_minv, {
-            "Minor Protocol Version Number", "infiniband.sdp.hh.minv",
+            "Minor Protocol Version Number", "infiniband_sdp.hh.minv",
             FT_UINT8, BASE_HEX, NULL, 0x0f, NULL, HFILL}
         },
         {&hf_ib_sdp_ipv,
-            {"IP version", "infiniband.sdp.hh.ipv",
+            {"IP version", "infiniband_sdp.hh.ipv",
             FT_UINT8, BASE_HEX, NULL, 0xf0, NULL, HFILL}
         },
         {&hf_ib_sdp_cap, {
-            "Capabilities", "infiniband.sdp.hh.cap",
+            "Capabilities", "infiniband_sdp.hh.cap",
             FT_UINT8, BASE_HEX, NULL, 0x0f, NULL, HFILL}
         },
         {&hf_ib_sdp_cap_invalidate, {
-            "INVALIDATE_CAP", "infiniband.sdp.hh.cap_invalidate",
+            "INVALIDATE_CAP", "infiniband_sdp.hh.cap_invalidate",
             FT_UINT8, BASE_HEX, NULL, 0x1, "Supports incoming Send w/Invalidate opcode", HFILL}
         },
         {&hf_ib_sdp_cap_extmaxadverts, {
-            "EXTENDED_MAXADVERTS", "infiniband.sdp.hh.cap_extmaxadverts",
+            "EXTENDED_MAXADVERTS", "infiniband_sdp.hh.cap_extmaxadverts",
             FT_UINT8, BASE_HEX, NULL, 0x2, "Extended MaxAdverts is used", HFILL}
         },
         {&hf_ib_sdp_maxadverts, {
-            "Maximum Advertisements", "infiniband.sdp.hh.maxadverts",
+            "Maximum Advertisements", "infiniband_sdp.hh.maxadverts",
             FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL}
         },
         {&hf_ib_sdp_desremrcvsz, {
-            "DesRemRcvSz", "infiniband.sdp.hh.desremrcvsz",
+            "DesRemRcvSz", "infiniband_sdp.hh.desremrcvsz",
             FT_UINT32, BASE_DEC, NULL, 0x0, "Desired Remote Receive Size", HFILL}
         },
         {&hf_ib_sdp_localrcvsz,
-            {"LocalRcvSz", "infiniband.sdp.hh.localrcvsz",
+            {"LocalRcvSz", "infiniband_sdp.hh.localrcvsz",
                 FT_UINT32, BASE_DEC, NULL, 0x0, "Local Receive Size", HFILL}
         },
         {&hf_ib_sdp_localport, {
-            "Local Port", "infiniband.sdp.hh.localport",
+            "Local Port", "infiniband_sdp.hh.localport",
             FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL}
         },
         {&hf_ib_sdp_src_ip, {
-            "Source IP", "infiniband.sdp.hh.src_ip",
+            "Source IP", "infiniband_sdp.hh.src_ip",
             FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL}
         },
         {&hf_ib_sdp_dst_ip, {
-            "Destination IP", "infiniband.sdp.hh.dst_ip",
+            "Destination IP", "infiniband_sdp.hh.dst_ip",
             FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL}
         },
         {&hf_ib_sdp_extmaxadverts, {
-            "Extended MaxAdverts", "infiniband.sdp.hh.extmaxadverts",
+            "Extended MaxAdverts", "infiniband_sdp.hh.extmaxadverts",
             FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL}
         },
         /* Rest of Headers */
         {&hf_ib_sdp_hah, {
-            "HelloAck Header", "infiniband.sdp.hah",
+            "HelloAck Header", "infiniband_sdp.hah",
             FT_NONE, BASE_NONE, NULL, 0x00, NULL, HFILL}
         },
         {&hf_ib_sdp_rwch, {
-            "RdmaWrCompl Header", "infiniband.sdp.rwch",
+            "RdmaWrCompl Header", "infiniband_sdp.rwch",
             FT_NONE, BASE_NONE, NULL, 0x00, "RDMA Write Complete", HFILL}
         },
         {&hf_ib_sdp_rrch, {
-            "RdmaRdCompl Header", "infiniband.sdp.rrch",
+            "RdmaRdCompl Header", "infiniband_sdp.rrch",
             FT_NONE, BASE_NONE, NULL, 0x00, "RDMA Read Complete", HFILL}
         },
         {&hf_ib_sdp_mch, {
-            "ModeChange Header", "infiniband.sdp.mch",
+            "ModeChange Header", "infiniband_sdp.mch",
             FT_NONE, BASE_NONE, NULL, 0x00, NULL, HFILL}
         },
         {&hf_ib_sdp_crbh, {
-            "ChRcvBuf Header", "infiniband.sdp.crbh",
+            "ChRcvBuf Header", "infiniband_sdp.crbh",
             FT_NONE, BASE_NONE, NULL, 0x00, "Change Receive private Buffer size", HFILL}
         },
         {&hf_ib_sdp_crbah, {
-            "ChRcvBufAck Header", "infiniband.sdp.crbah",
+            "ChRcvBufAck Header", "infiniband_sdp.crbah",
             FT_NONE, BASE_NONE, NULL, 0x00, "Change Receive private Buffer size Acknowledgement", HFILL}
         },
         {&hf_ib_sdp_suspch, {
-            "SuspComm Header", "infiniband.sdp.suspch",
+            "SuspComm Header", "infiniband_sdp.suspch",
             FT_NONE, BASE_NONE, NULL, 0x00, "Suspend Communication", HFILL}
         },
         {&hf_ib_sdp_sinkah, {
-            "SinkAvail Header", "infiniband.sdp.sinkah",
+            "SinkAvail Header", "infiniband_sdp.sinkah",
             FT_NONE, BASE_NONE, NULL, 0x00, "Data Sink Available", HFILL}
         },
         {&hf_ib_sdp_srcah, {
-            "SrcAvail Header", "infiniband.sdp.srcah",
+            "SrcAvail Header", "infiniband_sdp.srcah",
             FT_NONE, BASE_NONE, NULL, 0x00, "Data Source Available", HFILL}
         },
         {&hf_ib_sdp_data, {
-            "Data", "infiniband.sdp.Data",
+            "Data", "infiniband_sdp.Data",
             FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL}
         }
     };
@@ -487,9 +487,9 @@ proto_register_ib_sdp(void)
         &ett_ib_sdp_hh,
     };
 
-    proto_ib_sdp = proto_register_protocol("Infiniband Sockets Direct Protocol", "Infiniband SDP", "ib_sdp");
+    proto_ib_sdp = proto_register_protocol("Infiniband Sockets Direct Protocol", "Infiniband SDP", "infiniband_sdp");
 
-    new_register_dissector("infiniband.sdp", dissect_ib_sdp, proto_ib_sdp);
+    new_register_dissector("infiniband_sdp", dissect_ib_sdp, proto_ib_sdp);
 
     /* Required function calls to register the header fields and subtrees used */
     proto_register_field_array(proto_ib_sdp, hf, array_length(hf));
diff --git a/epan/dissectors/packet-ipmi-session.c b/epan/dissectors/packet-ipmi-session.c
index 58c1fddc84..a320759990 100644
--- a/epan/dissectors/packet-ipmi-session.c
+++ b/epan/dissectors/packet-ipmi-session.c
@@ -269,40 +269,40 @@ proto_register_ipmi_session(void)
 {
 	static hf_register_info hf[] = {
 		{ &hf_ipmi_session_authtype, {
-			"Authentication Type", "ipmi.session.authtype",
+			"Authentication Type", "ipmi_session.authtype",
 			FT_UINT8, BASE_HEX, VALS(ipmi_authtype_vals), 0, NULL, HFILL }},
 		{ &hf_ipmi_session_payloadtype,{
-			"Payload Type", "ipmi.session.payloadtype",
+			"Payload Type", "ipmi_session.payloadtype",
 			FT_UINT8, BASE_HEX, VALS(ipmi_payload_vals), 0x3f, NULL, HFILL }},
 		{ &hf_ipmi_session_payloadtype_auth,{
-			"Authenticated","ipmi.session.payloadtype.auth",
+			"Authenticated","ipmi_session.payloadtype.auth",
 			FT_BOOLEAN,8,  TFS(&ipmi_payload_aut_val), 0x40, NULL, HFILL }},
 		{ &hf_ipmi_session_payloadtype_enc,{
-			"Encryption","ipmi.session.payloadtype.enc",
+			"Encryption","ipmi_session.payloadtype.enc",
 			FT_BOOLEAN,8,  TFS(&ipmi_payload_enc_val), 0x80, NULL, HFILL }},
 		{ &hf_ipmi_session_oem_iana, {
-			"OEM IANA", "ipmi.session.oem.iana",
+			"OEM IANA", "ipmi_session.oem.iana",
 			FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }},
 		{ &hf_ipmi_session_oem_payload_id, {
-			"OEM Payload ID", "ipmi.session.oem.payloadid",
+			"OEM Payload ID", "ipmi_session.oem.payloadid",
 			FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }},
 		{ &hf_ipmi_session_sequence, {
-			"Session Sequence Number", "ipmi.session.sequence",
+			"Session Sequence Number", "ipmi_session.sequence",
 			FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }},
 		{ &hf_ipmi_session_id, {
-			"Session ID", "ipmi.session.id",
+			"Session ID", "ipmi_session.id",
 			FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL }},
 		{ &hf_ipmi_session_authcode, {
-			"Authentication Code", "ipmi.session.authcode",
+			"Authentication Code", "ipmi_session.authcode",
 			FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }},
 		{ &hf_ipmi_session_msg_len_1b, {
-			"Message Length", "ipmi.msg.len",
+			"Message Length", "ipmi_session.msg.len",
 			FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL }},
 		{ &hf_ipmi_session_msg_len_2b, {
-			"Message Length", "ipmi.msg.len",
+			"Message Length", "ipmi_session.msg.len",
 			FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL }},
 		{ &hf_ipmi_session_trailer, {
-			"IPMI Session Wrapper (trailer)", "ipmi.sess.trailer",
+			"IPMI Session Wrapper (trailer)", "ipmi_session.trailer",
 			FT_BYTES, BASE_NONE, NULL, 0, NULL, HFILL }},
 	};
 
@@ -310,7 +310,7 @@ proto_register_ipmi_session(void)
 
 	proto_ipmi_session = proto_register_protocol(
 			"Intelligent Platform Management Interface (Session Wrapper)", "IPMI Session",
-			"ipmi-session");
+			"ipmi_session");
 	proto_register_field_array(proto_ipmi_session, hf, array_length(hf));
 	proto_register_subtree_array(ett, array_length(ett));
 }
diff --git a/epan/dissectors/packet-isup.c b/epan/dissectors/packet-isup.c
index 67b265491f..1942c51c05 100644
--- a/epan/dissectors/packet-isup.c
+++ b/epan/dissectors/packet-isup.c
@@ -9168,22 +9168,22 @@ proto_register_isup(void)
         NULL, HFILL }},
 
     { &hf_isup_Pass_on_not_possible_indicator,
-      { "Pass on not possible indicator",  "isup_Pass_on_not_possible_ind",
+      { "Pass on not possible indicator",  "isup.Pass_on_not_possible_ind",
         FT_UINT8, BASE_HEX, VALS(isup_Pass_on_not_possible_indicator_vals),GF_8BIT_MASK,
         NULL, HFILL }},
 
     { &hf_isup_pass_on_not_possible_indicator2,
-      { "Pass on not possible indicator",  "isup_Pass_on_not_possible_val",
+      { "Pass on not possible indicator",  "isup.Pass_on_not_possible_val",
         FT_BOOLEAN, 8, TFS(&isup_pass_on_not_possible_indicator_value),E_8BIT_MASK,
         NULL, HFILL }},
 
     { &hf_isup_Broadband_narrowband_interworking_ind,
-      { "Broadband narrowband interworking indicator Bits JF",  "isup_broadband-narrowband_interworking_ind",
+      { "Broadband narrowband interworking indicator Bits JF",  "isup.broadband_narrowband_interworking_ind",
         FT_UINT8, BASE_HEX, VALS(ISUP_Broadband_narrowband_interworking_indicator_vals),BA_8BIT_MASK,
         NULL, HFILL }},
 
     { &hf_isup_Broadband_narrowband_interworking_ind2,
-      { "Broadband narrowband interworking indicator Bits GF",  "isup_broadband-narrowband_interworking_ind2",
+      { "Broadband narrowband interworking indicator Bits GF",  "isup.broadband_narrowband_interworking_ind2",
         FT_UINT8, BASE_HEX, VALS(ISUP_Broadband_narrowband_interworking_indicator_vals),GF_8BIT_MASK,
         NULL, HFILL }},
 
@@ -9506,63 +9506,63 @@ proto_register_isup(void)
         FT_STRING, BASE_NONE, NULL,0x0,
         NULL, HFILL }},
     {&hf_isup_apm_msg_fragments,
-     {"Message fragments", "isup_apm.msg.fragments",
+     {"Message fragments", "isup.apm.msg.fragments",
       FT_NONE, BASE_NONE, NULL, 0x00, NULL, HFILL }
     },
     {&hf_isup_apm_msg_fragment,
-     {"Message fragment", "isup_apm.msg.fragment",
+     {"Message fragment", "isup.apm.msg.fragment",
       FT_FRAMENUM, BASE_NONE, NULL, 0x00, NULL, HFILL }
     },
     {&hf_isup_apm_msg_fragment_overlap,
-     {"Message fragment overlap", "isup_apm.msg.fragment.overlap",
+     {"Message fragment overlap", "isup.apm.msg.fragment.overlap",
       FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }
     },
     {&hf_isup_apm_msg_fragment_overlap_conflicts,
-     {"Message fragment overlapping with conflicting data","isup_apm.msg.fragment.overlap.conflicts",
+     {"Message fragment overlapping with conflicting data","isup.apm.msg.fragment.overlap.conflicts",
       FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }
     },
     {&hf_isup_apm_msg_fragment_multiple_tails,
-     {"Message has multiple tail fragments", "isup_apm.msg.fragment.multiple_tails",
+     {"Message has multiple tail fragments", "isup.apm.msg.fragment.multiple_tails",
       FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }
     },
     {&hf_isup_apm_msg_fragment_too_long_fragment,
-     {"Message fragment too long", "isup_apm.msg.fragment.too_long_fragment",
+     {"Message fragment too long", "isup.apm.msg.fragment.too_long_fragment",
       FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL }
     },
     {&hf_isup_apm_msg_fragment_error,
-     {"Message defragmentation error", "isup_apm.msg.fragment.error",
+     {"Message defragmentation error", "isup.apm.msg.fragment.error",
       FT_FRAMENUM, BASE_NONE, NULL, 0x00, NULL, HFILL }
     },
     {&hf_isup_apm_msg_fragment_count,
-     {"Message fragment count", "isup_apm.msg.fragment.count",
+     {"Message fragment count", "isup.apm.msg.fragment.count",
       FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL }
     },
     {&hf_isup_apm_msg_reassembled_in,
-     {"Reassembled in", "isup_apm.msg.reassembled.in",
+     {"Reassembled in", "isup.apm.msg.reassembled.in",
       FT_FRAMENUM, BASE_NONE, NULL, 0x00, NULL, HFILL }
     },
     {&hf_isup_apm_msg_reassembled_length,
-     {"Reassembled ISUP length", "isup_apm.msg.reassembled.length",
+     {"Reassembled ISUP length", "isup.apm.msg.reassembled.length",
       FT_UINT32, BASE_DEC, NULL, 0x00, NULL, HFILL }
     },
     {&hf_isup_cvr_rsp_ind,
-     {"CVR Response Ind", "conn_rsp_ind",
+     {"CVR Response Ind", "isup.conn_rsp_ind",
       FT_UINT8, BASE_DEC, VALS(isup_cvr_rsp_ind_value), BA_8BIT_MASK,
       NULL, HFILL }},
     {&hf_isup_cvr_cg_car_ind,
-     {"CVR Circuit Group Carrier","cg_carrier_ind",
+     {"CVR Circuit Group Carrier","isup.cg_carrier_ind",
       FT_UINT8, BASE_HEX, VALS(isup_cvr_cg_car_ind_value), BA_8BIT_MASK,
       NULL, HFILL }},
     {&hf_isup_cvr_cg_double_seize,
-     {"Double Seize Control", "cg_char_ind.doubleSeize",
+     {"Double Seize Control", "isup.cg_char_ind.doubleSeize",
       FT_UINT8, BASE_HEX, VALS(isup_cvr_cg_double_seize_value), DC_8BIT_MASK,
       NULL, HFILL }},
     {&hf_isup_cvr_cg_alarm_car_ind,
-     {"Alarm Carrier Indicator", "cg_alarm_car_ind",
+     {"Alarm Carrier Indicator", "isup.cg_alarm_car_ind",
       FT_UINT8, BASE_HEX, VALS(isup_cvr_alarm_car_ind_value), FE_8BIT_MASK,
       NULL, HFILL }},
     {&hf_isup_cvr_cont_chk_ind,
-     {"Continuity Check Indicator","cg_alarm_cnt_chk",
+     {"Continuity Check Indicator","isup.cg_alarm_cnt_chk",
       FT_UINT8, BASE_HEX, VALS(isup_cvr_cont_chk_ind_value), HG_8BIT_MASK,
       NULL,HFILL }},
 
diff --git a/epan/dissectors/packet-jxta.c b/epan/dissectors/packet-jxta.c
index 597489d61e..fd49ac4957 100644
--- a/epan/dissectors/packet-jxta.c
+++ b/epan/dissectors/packet-jxta.c
@@ -2056,15 +2056,15 @@ void proto_register_jxta(void)
     /** our header fields */
     static hf_register_info hf[] = {
         {&hf_uri_addr,
-         {"Address", "uri.addr", FT_STRING, BASE_NONE, NULL, 0x0,
+         {"Address", "jxta.uri.addr", FT_STRING, BASE_NONE, NULL, 0x0,
           "URI Address (source or destination)", HFILL}
          },
         {&hf_uri_src,
-         {"Source", "uri.src", FT_STRING, BASE_NONE, NULL, 0x0,
+         {"Source", "jxta.uri.src", FT_STRING, BASE_NONE, NULL, 0x0,
           "URI Source", HFILL}
          },
         {&hf_uri_dst,
-         {"Destination", "uri.dst", FT_STRING, BASE_NONE, NULL, 0x0,
+         {"Destination", "jxta.uri.dst", FT_STRING, BASE_NONE, NULL, 0x0,
           "URI Destination", HFILL}
          },
         {&hf_jxta_udp,
diff --git a/epan/dissectors/packet-mpeg-descriptor.c b/epan/dissectors/packet-mpeg-descriptor.c
index dcc4abb253..ef7991df54 100644
--- a/epan/dissectors/packet-mpeg-descriptor.c
+++ b/epan/dissectors/packet-mpeg-descriptor.c
@@ -3418,83 +3418,83 @@ proto_register_mpeg_descriptor(void)
 
 		/* 0x5A Terrestrial Delivery System Descriptor */
 		{ &hf_mpeg_descr_terrestrial_delivery_centre_frequency, {
-			"Centre Frequency", "mpeg_descr_terr_delivery.centre_freq",
+			"Centre Frequency", "mpeg_descr.terr_delivery.centre_freq",
 			FT_STRING, BASE_NONE, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_mpeg_descr_terrestrial_delivery_bandwidth, {
-			"Bandwidth", "mpeg_descr_terr_delivery.bandwidth",
+			"Bandwidth", "mpeg_descr.terr_delivery.bandwidth",
 			FT_UINT8, BASE_HEX, VALS(mpeg_descr_terrestrial_delivery_bandwidth_vals),
 			MPEG_DESCR_TERRESTRIAL_DELIVERY_BANDWIDTH_MASK, NULL, HFILL
 		} },
 
 		{ &hf_mpeg_descr_terrestrial_delivery_priority, {
-			"Priority", "mpeg_descr_terr_delivery.priority",
+			"Priority", "mpeg_descr.terr_delivery.priority",
 			FT_UINT8, BASE_HEX, VALS(mpeg_descr_terrestrial_delivery_priority_vals),
 			MPEG_DESCR_TERRESTRIAL_DELIVERY_PRIORITY_MASK, NULL, HFILL
 		} },
 
 		{ &hf_mpeg_descr_terrestrial_delivery_time_slicing_indicator, {
-			"Time Slicing Indicator", "mpeg_descr_terr_delivery.time_slicing_ind",
+			"Time Slicing Indicator", "mpeg_descr.terr_delivery.time_slicing_ind",
 			FT_UINT8, BASE_HEX, VALS(mpeg_descr_terrestrial_delivery_time_slicing_indicator_vals),
 			MPEG_DESCR_TERRESTRIAL_DELIVERY_TIME_SLICING_INDICATOR_MASK, NULL, HFILL
 		} },
 
 		{ &hf_mpeg_descr_terrestrial_delivery_mpe_fec_indicator, {
-			"MPE-FEC Indicator", "mpeg_descr_terr_delivery.mpe_fec_ind",
+			"MPE-FEC Indicator", "mpeg_descr.terr_delivery.mpe_fec_ind",
 			FT_UINT8, BASE_HEX, VALS(mpeg_descr_terrestrial_delivery_mpe_fec_indicator_vals),
 			MPEG_DESCR_TERRESTRIAL_DELIVERY_MPE_FEC_INDICATOR_MASK, NULL, HFILL
 		} },
 
 		{ &hf_mpeg_descr_terrestrial_delivery_reserved1, {
-			"Reserved", "mpeg_descr_terr_delivery.reserved1",
+			"Reserved", "mpeg_descr.terr_delivery.reserved1",
 			FT_UINT8, BASE_HEX, NULL, MPEG_DESCR_TERRESTRIAL_DELIVERY_RESERVED1_MASK, NULL, HFILL
 		} },
 
 		{ &hf_mpeg_descr_terrestrial_delivery_constellation, {
-			"Constellation", "mpeg_descr_terr_delivery.constellation",
+			"Constellation", "mpeg_descr.terr_delivery.constellation",
 			FT_UINT8, BASE_HEX, VALS(mpeg_descr_terrestrial_delivery_constellation_vals),
 			MPEG_DESCR_TERRESTRIAL_DELIVERY_CONSTELLATION_MASK, NULL, HFILL
 		} },
 
 		{ &hf_mpeg_descr_terrestrial_delivery_hierarchy_information, {
-			"Hierarchy Information", "mpeg_descr_terr_delivery.hierarchy_information",
+			"Hierarchy Information", "mpeg_descr.terr_delivery.hierarchy_information",
 			FT_UINT8, BASE_HEX, VALS(mpeg_descr_terrestrial_delivery_hierarchy_information_vals),
 			MPEG_DESCR_TERRESTRIAL_DELIVERY_HIERARCHY_INFORMATION_MASK, NULL, HFILL
 		} },
 
 		{ &hf_mpeg_descr_terrestrial_delivery_code_rate_hp_stream, {
-			"Code Rate High Priority Stream", "mpeg_descr_terr_delivery.code_rate_hp_stream",
+			"Code Rate High Priority Stream", "mpeg_descr.terr_delivery.code_rate_hp_stream",
 			FT_UINT8, BASE_HEX, VALS(mpeg_descr_terrestrial_delivery_code_rate_vals),
 			MPEG_DESCR_TERRESTRIAL_DELIVERY_CODE_RATE_HP_STREAM_MASK, NULL, HFILL
 		} },
 
 		{ &hf_mpeg_descr_terrestrial_delivery_code_rate_lp_stream, {
-			"Code Rate Low Priority Stream", "mpeg_descr_terr_delivery.code_rate_lp_stream",
+			"Code Rate Low Priority Stream", "mpeg_descr.terr_delivery.code_rate_lp_stream",
 			FT_UINT8, BASE_HEX, VALS(mpeg_descr_terrestrial_delivery_code_rate_vals),
 			MPEG_DESCR_TERRESTRIAL_DELIVERY_CODE_RATE_LP_STREAM_MASK, NULL, HFILL
 		} },
 
 		{ &hf_mpeg_descr_terrestrial_delivery_guard_interval, {
-			"Guard Interval", "mpeg_descr_terr_delivery.guard_interval",
+			"Guard Interval", "mpeg_descr.terr_delivery.guard_interval",
 			FT_UINT8, BASE_HEX, VALS(mpeg_descr_terrestrial_delivery_guard_interval_vals),
 			MPEG_DESCR_TERRESTRIAL_DELIVERY_GUARD_INTERVAL_MASK, NULL, HFILL
 		} },
 
 		{ &hf_mpeg_descr_terrestrial_delivery_transmission_mode, {
-			"Transmission Mode", "mpeg_descr_terr_delivery.transmission_mode",
+			"Transmission Mode", "mpeg_descr.terr_delivery.transmission_mode",
 			FT_UINT8, BASE_HEX, VALS(mpeg_descr_terrestrial_delivery_transmission_mode_vals),
 			MPEG_DESCR_TERRESTRIAL_DELIVERY_TRANSMISSION_MODE_MASK, NULL, HFILL
 		} },
 
 		{ &hf_mpeg_descr_terrestrial_delivery_other_frequency_flag, {
-			"Other Frequency Flag", "mpeg_descr_terr_delivery.other_freq_flag",
+			"Other Frequency Flag", "mpeg_descr.terr_delivery.other_freq_flag",
 			FT_UINT8, BASE_HEX, VALS(mpeg_descr_terrestrial_delivery_other_frequency_flag_vals),
 			MPEG_DESCR_TERRESTRIAL_DELIVERY_OTHER_FREQUENCY_FLAG_MASK, NULL, HFILL
 		} },
 
 		{ &hf_mpeg_descr_terrestrial_delivery_reserved2, {
-			"Reserved", "mpeg_descr_terr_delivery.reserved2",
+			"Reserved", "mpeg_descr.terr_delivery.reserved2",
 			FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL
 		} },
 
diff --git a/epan/dissectors/packet-mpeg-dsmcc.c b/epan/dissectors/packet-mpeg-dsmcc.c
index 3b1dac1fd8..d1758d10fb 100644
--- a/epan/dissectors/packet-mpeg-dsmcc.c
+++ b/epan/dissectors/packet-mpeg-dsmcc.c
@@ -714,37 +714,37 @@ proto_register_dsmcc(void)
 	static hf_register_info hf[] = {
 		/* table 2-1 dsmccMessageHeader - start */
 		{ &hf_dsmcc_protocol_discriminator, {
-			"Protocol Discriminator", "dsmcc.protocol",
+			"Protocol Discriminator", "mpeg_dsmcc.protocol",
 			FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_type, {
-			"Type", "dsmcc.type",
+			"Type", "mpeg_dsmcc.type",
 			FT_UINT8, BASE_HEX|BASE_RANGE_STRING, RVALS(dsmcc_header_type_vals), 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_message_id, {
-			"Message ID", "dsmcc.message_id",
+			"Message ID", "mpeg_dsmcc.message_id",
 			FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_transaction_id, {
-			"Transaction ID", "dsmcc.transaction_id",
+			"Transaction ID", "mpeg_dsmcc.transaction_id",
 			FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_header_reserved, {
-			"Reserved", "dsmcc.header_reserved",
+			"Reserved", "mpeg_dsmcc.header_reserved",
 			FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_adaptation_length, {
-			"Adaptation Length", "dsmcc.adaptation_length",
+			"Adaptation Length", "mpeg_dsmcc.adaptation_length",
 			FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_message_length, {
-			"Message Length", "dsmcc.message_length",
+			"Message Length", "mpeg_dsmcc.message_length",
 			FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 		/* table 2-1 dsmccMessageHeader - end */
@@ -752,7 +752,7 @@ proto_register_dsmcc(void)
 
 		/* table 2-4 dsmccAdaptationHeader - start */
 		{ &hf_dsmcc_adaptation_type, {
-			"Adaptation Type", "dsmcc.adaptation_header.type",
+			"Adaptation Type", "mpeg_dsmcc.adaptation_header.type",
 			FT_UINT8, BASE_HEX|BASE_RANGE_STRING, RVALS(dsmcc_adaptation_header_vals), 0, NULL, HFILL
 		} },
 		/* table 2-4 dsmccAdaptationHeader - end */
@@ -760,17 +760,17 @@ proto_register_dsmcc(void)
 
 		/* table 2-6 dsmccConditionalAccess - start */
 		{ &hf_dsmcc_adaptation_ca_reserved, {
-			"Reserved", "dsmcc.adaptation_header.ca.reserved",
+			"Reserved", "mpeg_dsmcc.adaptation_header.ca.reserved",
 			FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_adaptation_ca_system_id, {
-			"System ID", "dsmcc.adaptation_header.ca.system_id",
+			"System ID", "mpeg_dsmcc.adaptation_header.ca.system_id",
 			FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_adaptation_ca_length, {
-			"System ID", "dsmcc.adaptation_header.ca.length",
+			"System ID", "mpeg_dsmcc.adaptation_header.ca.length",
 			FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 		/* table 2-6 dsmccConditionalAccess - end */
@@ -778,7 +778,7 @@ proto_register_dsmcc(void)
 
 		/* table 2-7 dsmccUserId - start */
 		{ &hf_dsmcc_adaptation_user_id_reserved, {
-			"Reserved", "dsmcc.adaptation_header.uid.reserved",
+			"Reserved", "mpeg_dsmcc.adaptation_header.uid.reserved",
 			FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 		/* table 2-7 dsmccUserId - start */
@@ -786,57 +786,57 @@ proto_register_dsmcc(void)
 
 		/* table 6-1 compatabilityDescriptor - start */
 		{ &hf_compat_desc_length, {
-			"Compatibility Descriptor Length", "dsmcc.dii.compat_desc_len",
+			"Compatibility Descriptor Length", "mpeg_dsmcc.dii.compat_desc_len",
 			FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_compat_desc_count, {
-			"Descriptor Length", "dsmcc.dii.compat_desc_count",
+			"Descriptor Length", "mpeg_dsmcc.dii.compat_desc_count",
 			FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_desc_type, {
-			"Descriptor Type", "dsmcc.dii.compat.type",
+			"Descriptor Type", "mpeg_dsmcc.dii.compat.type",
 			FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_desc_length, {
-			"Descriptor Length", "dsmcc.dii.compat.length",
+			"Descriptor Length", "mpeg_dsmcc.dii.compat.length",
 			FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_desc_spec_type, {
-			"Specifier Type", "dsmcc.dii.compat.spec_type",
+			"Specifier Type", "mpeg_dsmcc.dii.compat.spec_type",
 			FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_desc_spec_data, {
-			"Specifier Data", "dsmcc.dii.compat.spec_data",
+			"Specifier Data", "mpeg_dsmcc.dii.compat.spec_data",
 			FT_UINT24, BASE_HEX, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_desc_model, {
-			"Model", "dsmcc.dii.compat.model",
+			"Model", "mpeg_dsmcc.dii.compat.model",
 			FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_desc_version, {
-			"Version", "dsmcc.dii.compat.version",
+			"Version", "mpeg_dsmcc.dii.compat.version",
 			FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_desc_sub_desc_count, {
-			"Version", "dsmcc.dii.compat.sub_count",
+			"Version", "mpeg_dsmcc.dii.compat.sub_count",
 			FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_desc_sub_desc_type, {
-			"Type", "dsmcc.dii.compat.sub_type",
+			"Type", "mpeg_dsmcc.dii.compat.sub_type",
 			FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_desc_sub_desc_len, {
-			"Length", "dsmcc.dii.compat.sub_len",
+			"Length", "mpeg_dsmcc.dii.compat.sub_len",
 			FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 		/* table 6-1 compatabilityDescriptor - end */
@@ -844,12 +844,12 @@ proto_register_dsmcc(void)
 
 		/* table 7-3 dsmccDownloadDataHeader - start */
 		{ &hf_dsmcc_dd_download_id, {
-			"Download ID", "dsmcc.download_id",
+			"Download ID", "mpeg_dsmcc.download_id",
 			FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_dd_message_id, {
-			"Message ID", "dsmcc.message_id",
+			"Message ID", "mpeg_dsmcc.message_id",
 			FT_UINT16, BASE_HEX, VALS(dsmcc_dd_message_id_vals), 0, NULL, HFILL
 		} },
 		/* table 7-3 dsmccDownloadDataHeader - end */
@@ -857,62 +857,62 @@ proto_register_dsmcc(void)
 
 		/* table 7-6 downloadInfoIndication - start */
 		{ &hf_dsmcc_dii_download_id, {
-			"Download ID", "dsmcc.dii.download_id",
+			"Download ID", "mpeg_dsmcc.dii.download_id",
 			FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_dii_block_size, {
-			"Block Size", "dsmcc.dii.block_size",
+			"Block Size", "mpeg_dsmcc.dii.block_size",
 			FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_dii_window_size, {
-			"Window Size", "dsmcc.dii.window_size",
+			"Window Size", "mpeg_dsmcc.dii.window_size",
 			FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_dii_ack_period, {
-			"ACK Period", "dsmcc.dii.ack_period",
+			"ACK Period", "mpeg_dsmcc.dii.ack_period",
 			FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_dii_t_c_download_window, {
-			"Carousel Download Window", "dsmcc.dii.carousel_download_window",
+			"Carousel Download Window", "mpeg_dsmcc.dii.carousel_download_window",
 			FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_dii_t_c_download_scenario, {
-			"Carousel Download Scenario", "dsmcc.dii.carousel_download_scenario",
+			"Carousel Download Scenario", "mpeg_dsmcc.dii.carousel_download_scenario",
 			FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_dii_number_of_modules, {
-			"Number of Modules", "dsmcc.dii.module_count",
+			"Number of Modules", "mpeg_dsmcc.dii.module_count",
 			FT_UINT16, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_dii_module_id, {
-			"Module ID", "dsmcc.dii.module_id",
+			"Module ID", "mpeg_dsmcc.dii.module_id",
 			FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_dii_module_size, {
-			"Module Size", "dsmcc.dii.module_size",
+			"Module Size", "mpeg_dsmcc.dii.module_size",
 			FT_UINT32, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_dii_module_version, {
-			"Module Version", "dsmcc.dii.module_version",
+			"Module Version", "mpeg_dsmcc.dii.module_version",
 			FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_dii_module_info_length, {
-			"Module Info Length", "dsmcc.dii.module_info_length",
+			"Module Info Length", "mpeg_dsmcc.dii.module_info_length",
 			FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_dii_private_data_length, {
-			"Private Data Length", "dsmcc.dii.private_data_length",
+			"Private Data Length", "mpeg_dsmcc.dii.private_data_length",
 			FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 		/* table 7-6 downloadInfoIndication - end */
@@ -920,22 +920,22 @@ proto_register_dsmcc(void)
 
 		/* table 7-7 dsmccDownloadDataBlock - start */
 		{ &hf_dsmcc_ddb_module_id, {
-			"Module ID", "dsmcc.ddb.module_id",
+			"Module ID", "mpeg_dsmcc.ddb.module_id",
 			FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_ddb_version, {
-			"Version", "dsmcc.ddb.version",
+			"Version", "mpeg_dsmcc.ddb.version",
 			FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_ddb_reserved, {
-			"Reserved", "dsmcc.ddb.reserved",
+			"Reserved", "mpeg_dsmcc.ddb.reserved",
 			FT_UINT8, BASE_HEX, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_ddb_block_number, {
-			"Block Number", "dsmcc.ddb.block_num",
+			"Block Number", "mpeg_dsmcc.ddb.block_num",
 			FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL
 		} },
 		/* table 7-7 dsmccDownloadDataBlock - end */
@@ -953,7 +953,7 @@ proto_register_dsmcc(void)
 		} },
 
 		{ &hf_dsmcc_private_indicator, {
-			"Private Indicator", "dsmcc.private_indicator",
+			"Private Indicator", "mpeg_dsmcc.private_indicator",
 			FT_UINT16, BASE_DEC, NULL, DSMCC_PRIVATE_MASK, NULL, HFILL
 		} },
 
@@ -968,32 +968,32 @@ proto_register_dsmcc(void)
 		} },
 
 		{ &hf_dsmcc_table_id_extension, {
-			"Table ID Extension", "dsmcc.table_id_extension",
+			"Table ID Extension", "mpeg_dsmcc.table_id_extension",
 			FT_UINT16, BASE_HEX, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_reserved2, {
-			"Reserved", "dsmcc.reserved2",
+			"Reserved", "mpeg_dsmcc.reserved2",
 			FT_UINT8, BASE_HEX, NULL, DSMCC_RESERVED2_MASK, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_version_number, {
-			"Version Number", "dsmcc.version_number",
+			"Version Number", "mpeg_dsmcc.version_number",
 			FT_UINT8, BASE_DEC, NULL, DSMCC_VERSION_NUMBER_MASK, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_current_next_indicator, {
-			"Current Next Indicator", "dsmcc.current_next_indicator",
+			"Current Next Indicator", "mpeg_dsmcc.current_next_indicator",
 			FT_UINT8, BASE_DEC, NULL, DSMCC_CURRENT_NEXT_INDICATOR_MASK, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_section_number, {
-			"Section Number", "dsmcc.section_number",
+			"Section Number", "mpeg_dsmcc.section_number",
 			FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 
 		{ &hf_dsmcc_last_section_number, {
-			"Last Section Number", "dsmcc.last_section_number",
+			"Last Section Number", "mpeg_dsmcc.last_section_number",
 			FT_UINT8, BASE_DEC, NULL, 0, NULL, HFILL
 		} },
 
@@ -1003,7 +1003,7 @@ proto_register_dsmcc(void)
 		} },
 
 		{ &hf_dsmcc_checksum, {
-			"Checksum", "dsmcc.checksum",
+			"Checksum", "mpeg_dsmcc.checksum",
 			FT_UINT32, BASE_HEX, NULL, 0, NULL, HFILL
 		} },
 		/* table 9-2 - end */
@@ -1031,7 +1031,7 @@ proto_register_dsmcc(void)
 	};
 	module_t *dsmcc_module;
 
-	proto_dsmcc = proto_register_protocol("MPEG DSM-CC", "MPEG DSM-CC", "mpeg-dsmcc");
+	proto_dsmcc = proto_register_protocol("MPEG DSM-CC", "MPEG DSM-CC", "mpeg_dsmcc");
 
 	proto_register_field_array(proto_dsmcc, hf, array_length(hf));
 	proto_register_subtree_array(ett, array_length(ett));
diff --git a/epan/dissectors/packet-radius_packetcable.c b/epan/dissectors/packet-radius_packetcable.c
index 4fea204b40..85f6cea4db 100644
--- a/epan/dissectors/packet-radius_packetcable.c
+++ b/epan/dissectors/packet-radius_packetcable.c
@@ -445,336 +445,336 @@ void proto_register_packetcable(void) {
 
 	static hf_register_info hf[] = {
 		{ &hf_packetcable_em_header_version_id,
-		{ "Event Message Version ID","radius.vendor.pkt.emh.vid",
+		{ "Event Message Version ID","packetcable_avps.emh.vid",
 			FT_UINT16, BASE_DEC, NULL, 0x0,
 			"PacketCable Event Message header version ID", HFILL }
 		},
 		{ &hf_packetcable_bcid_timestamp,
-		{ "Timestamp","radius.vendor.pkt.bcid.ts",
+		{ "Timestamp","packetcable_avps.bcid.ts",
 			FT_UINT32, BASE_DEC, NULL, 0x0,
 			"PacketCable Event Message BCID Timestamp", HFILL }
 		},
 		{ &hf_packetcable_bcid_event_counter,
-		{ "Event Counter","radius.vendor.pkt.bcid.ec",
+		{ "Event Counter","packetcable_avps.bcid.ec",
 			FT_UINT32, BASE_DEC, NULL, 0x0,
 			"PacketCable Event Message BCID Event Counter", HFILL }
 		},
 		{ &hf_packetcable_em_header_event_message_type,
-		{ "Event Message Type","radius.vendor.pkt.emh.emt",
+		{ "Event Message Type","packetcable_avps.emh.emt",
 			FT_UINT16, BASE_DEC, radius_vendor_packetcable_event_message_vals, 0x0,
 			"PacketCable Event Message Type", HFILL }
 		},
 		{ &hf_packetcable_em_header_element_type,
-		{ "Element Type","radius.vendor.pkt.emh.et",
+		{ "Element Type","packetcable_avps.emh.et",
 			FT_UINT16, BASE_DEC, packetcable_em_header_element_type_vals, 0x0,
 			"PacketCable Event Message Element Type", HFILL }
 		},
 		{ &hf_packetcable_em_header_sequence_number,
-		{ "Sequence Number","radius.vendor.pkt.emh.sn",
+		{ "Sequence Number","packetcable_avps.emh.sn",
 			FT_UINT32, BASE_DEC, NULL, 0x0,
 			"PacketCable Event Message Sequence Number", HFILL }
 		},
 		{ &hf_packetcable_em_header_status,
-		{ "Status","radius.vendor.pkt.emh.st",
+		{ "Status","packetcable_avps.emh.st",
 			FT_UINT32, BASE_HEX, NULL, 0x0,
 			"PacketCable Event Message Status", HFILL }
 		},
 		{ &hf_packetcable_em_header_status_error_indicator,
-		{ "Status","radius.vendor.pkt.emh.st.ei",
+		{ "Status","packetcable_avps.emh.st.ei",
 			FT_UINT32, BASE_HEX, packetcable_em_header_status_error_indicator_vals,
 			PACKETCABLE_EMHS_EI_MASK,
 			"PacketCable Event Message Status Error Indicator", HFILL }
 		},
 		{ &hf_packetcable_em_header_status_event_origin,
-		{ "Event Origin","radius.vendor.pkt.emh.st.eo",
+		{ "Event Origin","packetcable_avps.emh.st.eo",
 			FT_UINT32, BASE_HEX, packetcable_em_header_status_event_origin_vals,
 			PACKETCABLE_EMHS_EO_MASK,
 			"PacketCable Event Message Status Event Origin", HFILL }
 		},
 		{ &hf_packetcable_em_header_status_event_message_proxied,
-		{ "Event Message Proxied","radius.vendor.pkt.emh.st.emp",
+		{ "Event Message Proxied","packetcable_avps.emh.st.emp",
 			FT_UINT32, BASE_HEX, packetcable_em_header_status_event_message_proxied_vals,
 			PACKETCABLE_EMHS_EMP_MASK,
 			"PacketCable Event Message Status Event Message Proxied", HFILL }
 		},
 		{ &hf_packetcable_em_header_priority,
-		{ "Priority","radius.vendor.pkt.emh.priority",
+		{ "Priority","packetcable_avps.emh.priority",
 			FT_UINT8, BASE_DEC, NULL, 0x0,
 			"PacketCable Event Message Priority", HFILL }
 		},
 		{ &hf_packetcable_em_header_attribute_count,
-		{ "Attribute Count","radius.vendor.pkt.emh.ac",
+		{ "Attribute Count","packetcable_avps.emh.ac",
 			FT_UINT16, BASE_DEC, NULL, 0x0,
 			"PacketCable Event Message Attribute Count", HFILL }
 		},
 		{ &hf_packetcable_em_header_event_object,
-		{ "Event Object","radius.vendor.pkt.emh.eo",
+		{ "Event Object","packetcable_avps.emh.eo",
 			FT_UINT8, BASE_DEC, NULL, 0x0,
 			"PacketCable Event Message Event Object", HFILL }
 		},
 		{ &hf_packetcable_call_termination_cause_source_document,
-		{ "Source Document","radius.vendor.pkt.ctc.sd",
+		{ "Source Document","packetcable_avps.ctc.sd",
 			FT_UINT16, BASE_HEX, packetcable_call_termination_cause_vals, 0x0,
 			"PacketCable Call Termination Cause Source Document", HFILL }
 		},
 		{ &hf_packetcable_call_termination_cause_code,
-		{ "Event Object","radius.vendor.pkt.ctc.cc",
+		{ "Event Object","packetcable_avps.ctc.cc",
 			FT_UINT32, BASE_DEC, NULL, 0x0,
 			"PacketCable Call Termination Cause Code", HFILL }
 		},
 		{ &hf_packetcable_trunk_group_id_trunk_type,
-		{ "Trunk Type","radius.vendor.pkt.tgid.tt",
+		{ "Trunk Type","packetcable_avps.tgid.tt",
 			FT_UINT16, BASE_HEX, packetcable_trunk_type_vals, 0x0,
 			"PacketCable Trunk Group ID Trunk Type", HFILL }
 		},
 		{ &hf_packetcable_trunk_group_id_trunk_number,
-		{ "Event Object","radius.vendor.pkt.tgid.tn",
+		{ "Event Object","packetcable_avps.tgid.tn",
 			FT_UINT32, BASE_DEC, NULL, 0x0,
 			"PacketCable Trunk Group ID Trunk Number", HFILL }
 		},
 		{ &hf_packetcable_qos_status,
-		{ "QoS Status","radius.vendor.pkt.qs",
+		{ "QoS Status","packetcable_avps.qs",
 			FT_UINT32, BASE_HEX, NULL, 0x0,
 			"PacketCable QoS Descriptor Attribute QoS Status", HFILL }
 		},
 		{ &hf_packetcable_qos_status_indication,
-		{ "Status Indication","radius.vendor.pkt.qs.si",
+		{ "Status Indication","packetcable_avps.qs.si",
 			FT_UINT32, BASE_DEC, packetcable_state_indication_vals, PACKETCABLE_QOS_STATE_INDICATION_MASK,
 			"PacketCable QoS Descriptor Attribute QoS State Indication", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_flags[0],
-		{ "Service Flow Scheduling Type","radius.vendor.pkt.qs.flags.sfst",
+		{ "Service Flow Scheduling Type","packetcable_avps.qs.flags.sfst",
 			FT_UINT32, BASE_DEC, NULL, PACKETCABLE_SERVICE_FLOW_SCHEDULING_TYPE_MASK,
 			"PacketCable QoS Descriptor Attribute Bitmask: Service Flow Scheduling Type", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_flags[1],
-		{ "Grant Interval","radius.vendor.pkt.qs.flags.gi",
+		{ "Grant Interval","packetcable_avps.qs.flags.gi",
 			FT_UINT32, BASE_DEC, NULL, PACKETCABLE_NOMINAL_GRANT_INTERVAL_MASK,
 			"PacketCable QoS Descriptor Attribute Bitmask: Grant Interval", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_flags[2],
-		{ "Tolerated Grant Jitter","radius.vendor.pkt.qs.flags.tgj",
+		{ "Tolerated Grant Jitter","packetcable_avps.qs.flags.tgj",
 			FT_UINT32, BASE_DEC, NULL, PACKETCABLE_TOLERATED_GRANT_JITTER_MASK,
 			"PacketCable QoS Descriptor Attribute Bitmask: Tolerated Grant Jitter", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_flags[3],
-		{ "Grants Per Interval","radius.vendor.pkt.qs.flags.gpi",
+		{ "Grants Per Interval","packetcable_avps.qs.flags.gpi",
 			FT_UINT32, BASE_DEC, NULL, PACKETCABLE_GRANTS_PER_INTERVAL_MASK,
 			"PacketCable QoS Descriptor Attribute Bitmask: Grants Per Interval", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_flags[4],
-		{ "Unsolicited Grant Size","radius.vendor.pkt.qs.flags.ugs",
+		{ "Unsolicited Grant Size","packetcable_avps.qs.flags.ugs",
 			FT_UINT32, BASE_DEC, NULL, PACKETCABLE_UNSOLICITED_GRANT_SIZE_MASK,
 			"PacketCable QoS Descriptor Attribute Bitmask: Unsolicited Grant Size", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_flags[5],
-		{ "Traffic Priority","radius.vendor.pkt.qs.flags.tp",
+		{ "Traffic Priority","packetcable_avps.qs.flags.tp",
 			FT_UINT32, BASE_DEC, NULL, PACKETCABLE_TRAFFIC_PRIORITY_MASK,
 			"PacketCable QoS Descriptor Attribute Bitmask: Traffic Priority", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_flags[6],
-		{ "Maximum Sustained Rate","radius.vendor.pkt.qs.flags.msr",
+		{ "Maximum Sustained Rate","packetcable_avps.qs.flags.msr",
 			FT_UINT32, BASE_DEC, NULL, PACKETCABLE_MAXIMUM_SUSTAINED_RATE_MASK,
 			"PacketCable QoS Descriptor Attribute Bitmask: Maximum Sustained Rate", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_flags[7],
-		{ "Maximum Traffic Burst","radius.vendor.pkt.qs.flags.mtb",
+		{ "Maximum Traffic Burst","packetcable_avps.qs.flags.mtb",
 			FT_UINT32, BASE_DEC, NULL, PACKETCABLE_MAXIMUM_TRAFFIC_BURST_MASK,
 			"PacketCable QoS Descriptor Attribute Bitmask: Maximum Traffic Burst", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_flags[8],
-		{ "Minimum Reserved Traffic Rate","radius.vendor.pkt.qs.flags.mrtr",
+		{ "Minimum Reserved Traffic Rate","packetcable_avps.qs.flags.mrtr",
 			FT_UINT32, BASE_DEC, NULL, PACKETCABLE_MINIMUM_RESERVED_TRAFFIC_RATE_MASK,
 			"PacketCable QoS Descriptor Attribute Bitmask: Minimum Reserved Traffic Rate", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_flags[9],
-		{ "Minimum Packet Size","radius.vendor.pkt.qs.flags.mps",
+		{ "Minimum Packet Size","packetcable_avps.qs.flags.mps",
 			FT_UINT32, BASE_DEC, NULL, PACKETCABLE_MINIMUM_PACKET_SIZE_MASK,
 			"PacketCable QoS Descriptor Attribute Bitmask: Minimum Packet Size", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_flags[10],
-		{ "Maximum Concatenated Burst","radius.vendor.pkt.qs.flags.mcb",
+		{ "Maximum Concatenated Burst","packetcable_avps.qs.flags.mcb",
 			FT_UINT32, BASE_DEC, NULL, PACKETCABLE_MAXIMUM_CONCATENATED_BURST_MASK,
 			"PacketCable QoS Descriptor Attribute Bitmask: Maximum Concatenated Burst", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_flags[11],
-		{ "Status Request/Transmission Policy","radius.vendor.pkt.qs.flags.srtp",
+		{ "Status Request/Transmission Policy","packetcable_avps.qs.flags.srtp",
 			FT_UINT32, BASE_DEC, NULL, PACKETCABLE_REQUEST_TRANSMISSION_POLICY_MASK,
 			"PacketCable QoS Descriptor Attribute Bitmask: Status Request/Transmission Policy", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_flags[12],
-		{ "Nominal Polling Interval","radius.vendor.pkt.qs.flags.npi",
+		{ "Nominal Polling Interval","packetcable_avps.qs.flags.npi",
 			FT_UINT32, BASE_DEC, NULL, PACKETCABLE_NOMINAL_POLLING_INTERVAL_MASK,
 			"PacketCable QoS Descriptor Attribute Bitmask: Nominal Polling Interval", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_flags[13],
-		{ "Tolerated Poll Jitter","radius.vendor.pkt.qs.flags.tpj",
+		{ "Tolerated Poll Jitter","packetcable_avps.qs.flags.tpj",
 			FT_UINT32, BASE_DEC, NULL, PACKETCABLE_TOLERATED_POLL_JITTER_MASK,
 			"PacketCable QoS Descriptor Attribute Bitmask: Tolerated Poll Jitter", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_flags[14],
-		{ "Type of Service Override","radius.vendor.pkt.qs.flags.toso",
+		{ "Type of Service Override","packetcable_avps.qs.flags.toso",
 			FT_UINT32, BASE_DEC, NULL, PACKETCABLE_IP_TYPE_OF_SERVICE_OVERRIDE_MASK,
 			"PacketCable QoS Descriptor Attribute Bitmask: Type of Service Override", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_flags[15],
-		{ "Maximum Downstream Latency","radius.vendor.pkt.qs.flags.mdl",
+		{ "Maximum Downstream Latency","packetcable_avps.qs.flags.mdl",
 			FT_UINT32, BASE_DEC, NULL, PACKETCABLE_MAXIMUM_DOWNSTREAM_LATENCY_MASK,
 			"PacketCable QoS Descriptor Attribute Bitmask: Maximum Downstream Latency", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_fields[0],
-		{ "Service Flow Scheduling Type","radius.vendor.pkt.qs.sfst",
+		{ "Service Flow Scheduling Type","packetcable_avps.qs.sfst",
 			FT_UINT32, BASE_DEC, NULL, 0x0,
 			"PacketCable QoS Descriptor Attribute Service Flow Scheduling Type", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_fields[1],
-		{ "Grant Interval","radius.vendor.pkt.qs.gi",
+		{ "Grant Interval","packetcable_avps.qs.gi",
 			FT_UINT32, BASE_DEC, NULL, 0x0,
 			"PacketCable QoS Descriptor Attribute Grant Interval", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_fields[2],
-		{ "Tolerated Grant Jitter","radius.vendor.pkt.qs.tgj",
+		{ "Tolerated Grant Jitter","packetcable_avps.qs.tgj",
 			FT_UINT32, BASE_DEC, NULL, 0x0,
 			"PacketCable QoS Descriptor Attribute Tolerated Grant Jitter", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_fields[3],
-		{ "Grants Per Interval","radius.vendor.pkt.qs.gpi",
+		{ "Grants Per Interval","packetcable_avps.qs.gpi",
 			FT_UINT32, BASE_DEC, NULL, 0x0,
 			"PacketCable QoS Descriptor Attribute Grants Per Interval", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_fields[4],
-		{ "Unsolicited Grant Size","radius.vendor.pkt.qs.ugs",
+		{ "Unsolicited Grant Size","packetcable_avps.qs.ugs",
 			FT_UINT32, BASE_DEC, NULL, 0x0,
 			"PacketCable QoS Descriptor Attribute Unsolicited Grant Size", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_fields[5],
-		{ "Traffic Priority","radius.vendor.pkt.qs.tp",
+		{ "Traffic Priority","packetcable_avps.qs.tp",
 			FT_UINT32, BASE_DEC, NULL, 0x0,
 			"PacketCable QoS Descriptor Attribute Traffic Priority", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_fields[6],
-		{ "Maximum Sustained Rate","radius.vendor.pkt.qs.msr",
+		{ "Maximum Sustained Rate","packetcable_avps.qs.msr",
 			FT_UINT32, BASE_DEC, NULL, 0x0,
 			"PacketCable QoS Descriptor Attribute Maximum Sustained Rate", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_fields[7],
-		{ "Maximum Traffic Burst","radius.vendor.pkt.qs.mtb",
+		{ "Maximum Traffic Burst","packetcable_avps.qs.mtb",
 			FT_UINT32, BASE_DEC, NULL, 0x0,
 			"PacketCable QoS Descriptor Attribute Maximum Traffic Burst", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_fields[8],
-		{ "Minimum Reserved Traffic Rate","radius.vendor.pkt.qs.mrtr",
+		{ "Minimum Reserved Traffic Rate","packetcable_avps.qs.mrtr",
 			FT_UINT32, BASE_DEC, NULL, 0x0,
 			"PacketCable QoS Descriptor Attribute Minimum Reserved Traffic Rate", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_fields[9],
-		{ "Minimum Packet Size","radius.vendor.pkt.qs.mps",
+		{ "Minimum Packet Size","packetcable_avps.qs.mps",
 			FT_UINT32, BASE_DEC, NULL, 0x0,
 			"PacketCable QoS Descriptor Attribute Minimum Packet Size", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_fields[10],
-		{ "Maximum Concatenated Burst","radius.vendor.pkt.qs.mcb",
+		{ "Maximum Concatenated Burst","packetcable_avps.qs.mcb",
 			FT_UINT32, BASE_DEC, NULL, 0x0,
 			"PacketCable QoS Descriptor Attribute Maximum Concatenated Burst", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_fields[11],
-		{ "Status Request/Transmission Policy","radius.vendor.pkt.qs.srtp",
+		{ "Status Request/Transmission Policy","packetcable_avps.qs.srtp",
 			FT_UINT32, BASE_DEC, NULL, 0x0,
 			"PacketCable QoS Descriptor Attribute Status Request/Transmission Policy", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_fields[12],
-		{ "Nominal Polling Interval","radius.vendor.pkt.qs.npi",
+		{ "Nominal Polling Interval","packetcable_avps.qs.npi",
 			FT_UINT32, BASE_DEC, NULL, 0x0,
 			"PacketCable QoS Descriptor Attribute Nominal Polling Interval", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_fields[13],
-		{ "Tolerated Poll Jitter","radius.vendor.pkt.qs.tpj",
+		{ "Tolerated Poll Jitter","packetcable_avps.qs.tpj",
 			FT_UINT32, BASE_DEC, NULL, 0x0,
 			"PacketCable QoS Descriptor Attribute Tolerated Poll Jitter", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_fields[14],
-		{ "Type of Service Override","radius.vendor.pkt.qs.toso",
+		{ "Type of Service Override","packetcable_avps.qs.toso",
 			FT_UINT32, BASE_DEC, NULL, 0x0,
 			"PacketCable QoS Descriptor Attribute Type of Service Override", HFILL }
 		},
 		{ &hf_packetcable_qos_desc_fields[15],
-		{ "Maximum Downstream Latency","radius.vendor.pkt.qs.mdl",
+		{ "Maximum Downstream Latency","packetcable_avps.qs.mdl",
 			FT_UINT32, BASE_DEC, NULL, 0x0,
 			"PacketCable QoS Descriptor Attribute Maximum Downstream Latency", HFILL }
 		},
 		{ &hf_packetcable_time_adjustment,
-		{ "Time Adjustment","radius.vendor.pkt.ti",
+		{ "Time Adjustment","packetcable_avps.ti",
 			FT_UINT64, BASE_DEC, NULL, 0x0,
 			"PacketCable Time Adjustment", HFILL }
 		},
 		{ &hf_packetcable_redirected_from_info_number_of_redirections,
-		{ "Number-of-Redirections","radius.vendor.pkt.rfi.nr",
+		{ "Number-of-Redirections","packetcable_avps.rfi.nr",
 			FT_UINT16, BASE_DEC, NULL, 0x0,
 			"PacketCable Redirected-From-Info Number-of-Redirections", HFILL }
 		},
 		{ &hf_packetcable_electronic_surveillance_indication_df_cdc_address,
-		{ "DF_CDC_Address","radius.vendor.pkt.esi.dfcdca",
+		{ "DF_CDC_Address","packetcable_avps.esi.dfcdca",
 			FT_IPv4, BASE_NONE, NULL, 0x0,
 			"PacketCable Electronic-Surveillance-Indication DF_CDC_Address", HFILL }
 		},
 		{ &hf_packetcable_electronic_surveillance_indication_df_ccc_address,
-		{ "DF_CDC_Address","radius.vendor.pkt.esi.dfccca",
+		{ "DF_CDC_Address","packetcable_avps.esi.dfccca",
 			FT_IPv4, BASE_NONE, NULL, 0x0,
 			"PacketCable Electronic-Surveillance-Indication DF_CCC_Address", HFILL }
 		},
 		{ &hf_packetcable_electronic_surveillance_indication_cdc_port,
-		{ "CDC-Port","radius.vendor.pkt.esi.cdcp",
+		{ "CDC-Port","packetcable_avps.esi.cdcp",
 			FT_UINT16, BASE_DEC, NULL, 0x0,
 			"PacketCable Electronic-Surveillance-Indication CDC-Port", HFILL }
 		},
 		{ &hf_packetcable_electronic_surveillance_indication_ccc_port,
-		{ "CCC-Port","radius.vendor.pkt.esi.cccp",
+		{ "CCC-Port","packetcable_avps.esi.cccp",
 			FT_UINT16, BASE_DEC, NULL, 0x0,
 			"PacketCable Electronic-Surveillance-Indication CCC-Port", HFILL }
 		},
 
 		{ &hf_packetcable_terminal_display_info_terminal_display_status_bitmask,
-		{ "Terminal_Display_Status_Bitmask","radius.vendor.pkt.tdi.sbm",
+		{ "Terminal_Display_Status_Bitmask","packetcable_avps.tdi.sbm",
 			FT_UINT8, BASE_HEX, NULL, 0xff,
 			"PacketCable Terminal_Display_Info Terminal_Display_Status_Bitmask", HFILL }
 		},
 		{ &hf_packetcable_terminal_display_info_sbm_general_display,
-		{ "General_Display","radius.vendor.pkt.tdi.sbm.gd",
+		{ "General_Display","packetcable_avps.tdi.sbm.gd",
 			FT_BOOLEAN, 8, NULL, 0x01,
 			"PacketCable Terminal_Display_Info Terminal_Display_Status_Bitmask General_Display", HFILL }
 		},
 		{ &hf_packetcable_terminal_display_info_sbm_calling_number,
-		{ "Calling_Number","radius.vendor.pkt.tdi.sbm.cnum",
+		{ "Calling_Number","packetcable_avps.tdi.sbm.cnum",
 			FT_BOOLEAN, 8, NULL, 0x02,
 			"PacketCable Terminal_Display_Info Terminal_Display_Status_Bitmask Calling_Number", HFILL }
 		},
 		{ &hf_packetcable_terminal_display_info_sbm_calling_name,
-		{ "Calling_Name","radius.vendor.pkt.tdi.sbm.cname",
+		{ "Calling_Name","packetcable_avps.tdi.sbm.cname",
 			FT_BOOLEAN, 8, NULL, 0x04,
 			"PacketCable Terminal_Display_Info Terminal_Display_Status_Bitmask Calling_Name", HFILL }
 		},
 		{ &hf_packetcable_terminal_display_info_sbm_message_waiting,
-		{ "Message_Waiting","radius.vendor.pkt.tdi.sbm.mw",
+		{ "Message_Waiting","packetcable_avps.tdi.sbm.mw",
 			FT_BOOLEAN, 8, NULL, 0x08,
 			"PacketCable Terminal_Display_Info Terminal_Display_Status_Bitmask Message_Waiting", HFILL }
 		},
 		{ &hf_packetcable_terminal_display_info_general_display,
-		{ "General_Display","radius.vendor.pkt.tdi.gd",
+		{ "General_Display","packetcable_avps.tdi.gd",
 			FT_STRING, BASE_NONE, NULL, 0,
 			"PacketCable Terminal_Display_Info General_Display", HFILL }
 		},
 		{ &hf_packetcable_terminal_display_info_calling_number,
-		{ "Calling_Number","radius.vendor.pkt.tdi.cnum",
+		{ "Calling_Number","packetcable_avps.tdi.cnum",
 			FT_STRING, BASE_NONE, NULL, 0,
 			"PacketCable Terminal_Display_Info Calling_Number", HFILL }
 		},
 		{ &hf_packetcable_terminal_display_info_calling_name,
-		{ "Calling_Name","radius.vendor.pkt.tdi.cname",
+		{ "Calling_Name","packetcable_avps.tdi.cname",
 			FT_STRING, BASE_NONE, NULL, 0,
 			"PacketCable Terminal_Display_Info Calling_Name", HFILL }
 		},
 		{ &hf_packetcable_terminal_display_info_message_waiting,
-		{ "Message_Waiting","radius.vendor.pkt.tdi.mw",
+		{ "Message_Waiting","packetcable_avps.tdi.mw",
 			FT_STRING, BASE_NONE, NULL, 0,
 			"PacketCable Terminal_Display_Info Message_Waiting", HFILL }
 		}
@@ -787,7 +787,7 @@ void proto_register_packetcable(void) {
 		&ett_packetcable_term_dsply
 	};
 
-	proto_packetcable = proto_register_protocol("PacketCable AVPs", "PACKETCABLE", "paketcable_avps");
+	proto_packetcable = proto_register_protocol("PacketCable AVPs", "PACKETCABLE", "packetcable_avps");
 
 	proto_register_field_array(proto_packetcable, hf, array_length(hf));
 	proto_register_subtree_array(ett, array_length(ett));
diff --git a/epan/dissectors/packet-retix-bpdu.c b/epan/dissectors/packet-retix-bpdu.c
index f8caa2b9bc..ae38ce4288 100644
--- a/epan/dissectors/packet-retix-bpdu.c
+++ b/epan/dissectors/packet-retix-bpdu.c
@@ -92,23 +92,23 @@ proto_register_retix_bpdu(void)
 {
   static hf_register_info hf[] = {
     { &hf_retix_bpdu_root_mac,
-    { "Root MAC",  "rstp.root.hw", FT_ETHER, BASE_NONE, NULL, 0x0,
+    { "Root MAC",  "r-stp.root.hw", FT_ETHER, BASE_NONE, NULL, 0x0,
     NULL, HFILL}},
 
     { &hf_retix_bpdu_bridge_mac,
-    { "Bridge MAC", "rstp.bridge.hw", FT_ETHER, BASE_NONE, NULL, 0x0,
+    { "Bridge MAC", "r-stp.bridge.hw", FT_ETHER, BASE_NONE, NULL, 0x0,
     NULL, HFILL}},
 
     { &hf_retix_bpdu_max_age,
-    { "Max Age", "rstp.maxage", FT_UINT16, BASE_DEC, NULL, 0x0,
+    { "Max Age", "r-stp.maxage", FT_UINT16, BASE_DEC, NULL, 0x0,
     NULL, HFILL}},
 
     { &hf_retix_bpdu_hello_time,
-    { "Hello Time", "rstp.hello", FT_UINT16, BASE_DEC, NULL, 0x0,
+    { "Hello Time", "r-stp.hello", FT_UINT16, BASE_DEC, NULL, 0x0,
     NULL, HFILL}},
 
     { &hf_retix_bpdu_forward_delay,
-    { "Forward Delay", "rstp.forward", FT_UINT16, BASE_DEC, NULL, 0x0,
+    { "Forward Delay", "r-stp.forward", FT_UINT16, BASE_DEC, NULL, 0x0,
     NULL, HFILL}},
   };