From Chris Maynard:

Incorrect display filter field naming convention.

svn path=/trunk/; revision=22740

1 files changed, 108 insertions, 108 deletions

diff --git a/epan/dissectors/packet-slowprotocols.c b/epan/dissectors/packet-slowprotocols.c
index 15d6d8d8fe..33e5cafc89 100644
--- a/epan/dissectors/packet-slowprotocols.c
+++ b/epan/dissectors/packet-slowprotocols.c
@@ -2375,212 +2375,212 @@ proto_register_slow_protocols(void)
  *  LACP portion
  */
     { &hf_lacpdu_version_number,
-      { "LACP Version Number",    "lacp.version",
+      { "LACP Version Number",    "slow.lacp.version",
          FT_UINT8,    BASE_HEX,    NULL,    0x0,
         "Identifies the LACP version", HFILL }},
 
     { &hf_lacpdu_actor_type,
-      { "Actor Information",    "lacp.actorInfo",
+      { "Actor Information",    "slow.lacp.actorInfo",
         FT_UINT8,    BASE_HEX,    NULL,    0x0,
         "TLV type = Actor", HFILL }},
 
     { &hf_lacpdu_actor_info_len,
-      { "Actor Information Length",            "lacp.actorInfoLen",
+      { "Actor Information Length",            "slow.lacp.actorInfoLen",
         FT_UINT8,    BASE_HEX,    NULL,    0x0,
         "The length of the Actor TLV", HFILL }},
 
     { &hf_lacpdu_actor_sys_priority,
-      { "Actor System Priority",  "lacp.actorSysPriority",
+      { "Actor System Priority",  "slow.lacp.actorSysPriority",
         FT_UINT16,    BASE_DEC,    NULL,    0x0,
         "The priority assigned to this System by management or admin", HFILL }},
 
     { &hf_lacpdu_actor_sys,
-      { "Actor System",            "lacp.actorSystem",
+      { "Actor System",            "slow.lacp.actorSystem",
         FT_ETHER,    BASE_NONE,    NULL,    0x0,
         "The Actor's System ID encoded as a MAC address", HFILL }},
 
     { &hf_lacpdu_actor_key,
-      { "Actor Key",            "lacp.actorKey",
+      { "Actor Key",            "slow.lacp.actorKey",
         FT_UINT16,    BASE_DEC,    NULL,    0x0,
         "The operational Key value assigned to the port by the Actor", HFILL }},
 
     { &hf_lacpdu_actor_port_priority,
-      { "Actor Port Priority",            "lacp.actorPortPriority",
+      { "Actor Port Priority",            "slow.lacp.actorPortPriority",
         FT_UINT16,    BASE_DEC,    NULL,    0x0,
         "The priority assigned to the port by the Actor (via Management or Admin)", HFILL }},
 
     { &hf_lacpdu_actor_port,
-      { "Actor Port",            "lacp.actorPort",
+      { "Actor Port",            "slow.lacp.actorPort",
         FT_UINT16,    BASE_DEC,    NULL,    0x0,
         "The port number assigned to the port by the Actor (via Management or Admin)", HFILL }},
 
     { &hf_lacpdu_actor_state,
-      { "Actor State",            "lacp.actorState",
+      { "Actor State",            "slow.lacp.actorState",
         FT_UINT8,    BASE_HEX,    NULL,    0x0,
         "The Actor's state variables for the port, encoded as bits within a single octet", HFILL }},
 
     { &hf_lacpdu_flags_a_activity,
-      { "LACP Activity",        "lacp.actorState.activity",
+      { "LACP Activity",        "slow.lacp.actorState.activity",
         FT_BOOLEAN,    8,        TFS(&yesno),    LACPDU_FLAGS_ACTIVITY,
         "Activity control value for this link. Active = 1, Passive = 0", HFILL }},
 
     { &hf_lacpdu_flags_a_timeout,
-      { "LACP Timeout",        "lacp.actorState.timeout",
+      { "LACP Timeout",        "slow.lacp.actorState.timeout",
         FT_BOOLEAN,    8,        TFS(&yesno),    LACPDU_FLAGS_TIMEOUT,
         "Timeout control value for this link. Short Timeout = 1, Long Timeout = 0", HFILL }},
 
     { &hf_lacpdu_flags_a_aggregation,
-      { "Aggregation",        "lacp.actorState.aggregation",
+      { "Aggregation",        "slow.lacp.actorState.aggregation",
         FT_BOOLEAN,    8,        TFS(&yesno),    LACPDU_FLAGS_AGGREGATION,
         "Aggregatable = 1, Individual = 0", HFILL }},
 
     { &hf_lacpdu_flags_a_sync,
-      { "Synchronization",        "lacp.actorState.synchronization",
+      { "Synchronization",        "slow.lacp.actorState.synchronization",
         FT_BOOLEAN,    8,        TFS(&yesno),    LACPDU_FLAGS_SYNC,
         "In Sync = 1, Out of Sync = 0", HFILL }},
 
     { &hf_lacpdu_flags_a_collecting,
-      { "Collecting",        "lacp.actorState.collecting",
+      { "Collecting",        "slow.lacp.actorState.collecting",
         FT_BOOLEAN,    8,        TFS(&yesno),    LACPDU_FLAGS_COLLECTING,
         "Collection of incoming frames is: Enabled = 1, Disabled = 0", HFILL }},
 
     { &hf_lacpdu_flags_a_distrib,
-      { "Distributing",        "lacp.actorState.distributing",
+      { "Distributing",        "slow.lacp.actorState.distributing",
         FT_BOOLEAN,    8,        TFS(&yesno),    LACPDU_FLAGS_DISTRIB,
         "Distribution of outgoing frames is: Enabled = 1, Disabled = 0", HFILL }},
 
     { &hf_lacpdu_flags_a_defaulted,
-      { "Defaulted",        "lacp.actorState.defaulted",
+      { "Defaulted",        "slow.lacp.actorState.defaulted",
         FT_BOOLEAN,    8,        TFS(&yesno),    LACPDU_FLAGS_DEFAULTED,
         "1 = Actor Rx machine is using DEFAULT Partner info, 0 = using info in Rx'd LACPDU", HFILL }},
 
     { &hf_lacpdu_flags_a_expired,
-      { "Expired",        "lacp.actorState.expired",
+      { "Expired",        "slow.lacp.actorState.expired",
         FT_BOOLEAN,    8,        TFS(&yesno),    LACPDU_FLAGS_EXPIRED,
         "1 = Actor Rx machine is EXPIRED, 0 = is NOT EXPIRED", HFILL }},
 
     { &hf_lacpdu_actor_reserved,
-      { "Reserved",        "lacp.reserved",
+      { "Reserved",        "slow.lacp.reserved",
         FT_BYTES,    BASE_NONE,    NULL,    0x0,
         "", HFILL }},
 
     { &hf_lacpdu_partner_type,
-      { "Partner Information",    "lacp.partnerInfo",
+      { "Partner Information",    "slow.lacp.partnerInfo",
         FT_UINT8,    BASE_HEX,    NULL,    0x0,
         "TLV type = Partner", HFILL }},
 
     { &hf_lacpdu_partner_info_len,
-      { "Partner Information Length",            "lacp.partnerInfoLen",
+      { "Partner Information Length",            "slow.lacp.partnerInfoLen",
         FT_UINT8,    BASE_HEX,    NULL,    0x0,
         "The length of the Partner TLV", HFILL }},
 
     { &hf_lacpdu_partner_sys_priority,
-      { "Partner System Priority",  "lacp.partnerSysPriority",
+      { "Partner System Priority",  "slow.lacp.partnerSysPriority",
         FT_UINT16,    BASE_DEC,    NULL,    0x0,
         "The priority assigned to the Partner System by management or admin", HFILL }},
 
     { &hf_lacpdu_partner_sys,
-      { "Partner System",            "lacp.partnerSystem",
+      { "Partner System",            "slow.lacp.partnerSystem",
         FT_ETHER,    BASE_NONE,    NULL,    0x0,
         "The Partner's System ID encoded as a MAC address", HFILL }},
 
     { &hf_lacpdu_partner_key,
-      { "Partner Key",            "lacp.partnerKey",
+      { "Partner Key",            "slow.lacp.partnerKey",
         FT_UINT16,    BASE_DEC,    NULL,    0x0,
         "The operational Key value assigned to the port associated with this link by the Partner", HFILL }},
 
     { &hf_lacpdu_partner_port_priority,
-      { "Partner Port Priority",            "lacp.partnerPortPriority",
+      { "Partner Port Priority",            "slow.lacp.partnerPortPriority",
         FT_UINT16,    BASE_DEC,    NULL,    0x0,
         "The priority assigned to the port by the Partner (via Management or Admin)", HFILL }},
 
     { &hf_lacpdu_partner_port,
-      { "Partner Port",            "lacp.partnerPort",
+      { "Partner Port",            "slow.lacp.partnerPort",
         FT_UINT16,    BASE_DEC,    NULL,    0x0,
         "The port number associated with this link assigned to the port by the Partner (via Management or Admin)", HFILL }},
 
     { &hf_lacpdu_partner_state,
-      { "Partner State",            "lacp.partnerState",
+      { "Partner State",            "slow.lacp.partnerState",
         FT_UINT8,    BASE_HEX,    NULL,    0x0,
         "The Partner's state variables for the port, encoded as bits within a single octet", HFILL }},
 
     { &hf_lacpdu_flags_p_activity,
-      { "LACP Activity",        "lacp.partnerState.activity",
+      { "LACP Activity",        "slow.lacp.partnerState.activity",
         FT_BOOLEAN,    8,        TFS(&yesno),    LACPDU_FLAGS_ACTIVITY,
         "Activity control value for this link. Active = 1, Passive = 0", HFILL }},
 
     { &hf_lacpdu_flags_p_timeout,
-      { "LACP Timeout",        "lacp.partnerState.timeout",
+      { "LACP Timeout",        "slow.lacp.partnerState.timeout",
         FT_BOOLEAN,    8,        TFS(&yesno),    LACPDU_FLAGS_TIMEOUT,
         "Timeout control value for this link. Short Timeout = 1, Long Timeout = 0", HFILL }},
 
     { &hf_lacpdu_flags_p_aggregation,
-      { "Aggregation",        "lacp.partnerState.aggregation",
+      { "Aggregation",        "slow.lacp.partnerState.aggregation",
         FT_BOOLEAN,    8,        TFS(&yesno),    LACPDU_FLAGS_AGGREGATION,
         "Aggregatable = 1, Individual = 0", HFILL }},
 
     { &hf_lacpdu_flags_p_sync,
-      { "Synchronization",        "lacp.partnerState.synchronization",
+      { "Synchronization",        "slow.lacp.partnerState.synchronization",
         FT_BOOLEAN,    8,        TFS(&yesno),    LACPDU_FLAGS_SYNC,
         "In Sync = 1, Out of Sync = 0", HFILL }},
 
     { &hf_lacpdu_flags_p_collecting,
-      { "Collecting",        "lacp.partnerState.collecting",
+      { "Collecting",        "slow.lacp.partnerState.collecting",
         FT_BOOLEAN,    8,        TFS(&yesno),    LACPDU_FLAGS_COLLECTING,
         "Collection of incoming frames is: Enabled = 1, Disabled = 0", HFILL }},
 
     { &hf_lacpdu_flags_p_distrib,
-      { "Distributing",        "lacp.partnerState.distributing",
+      { "Distributing",        "slow.lacp.partnerState.distributing",
         FT_BOOLEAN,    8,        TFS(&yesno),    LACPDU_FLAGS_DISTRIB,
         "Distribution of outgoing frames is: Enabled = 1, Disabled = 0", HFILL }},
 
     { &hf_lacpdu_flags_p_defaulted,
-      { "Defaulted",        "lacp.partnerState.defaulted",
+      { "Defaulted",        "slow.lacp.partnerState.defaulted",
         FT_BOOLEAN,    8,        TFS(&yesno),    LACPDU_FLAGS_DEFAULTED,
         "1 = Actor Rx machine is using DEFAULT Partner info, 0 = using info in Rx'd LACPDU", HFILL }},
 
     { &hf_lacpdu_flags_p_expired,
-      { "Expired",        "lacp.partnerState.expired",
+      { "Expired",        "slow.lacp.partnerState.expired",
         FT_BOOLEAN,    8,        TFS(&yesno),    LACPDU_FLAGS_EXPIRED,
         "1 = Actor Rx machine is EXPIRED, 0 = is NOT EXPIRED", HFILL }},
 
     { &hf_lacpdu_partner_reserved,
-      { "Reserved",        "lacp.reserved",
+      { "Reserved",        "slow.lacp.reserved",
         FT_BYTES,    BASE_NONE,    NULL,    0x0,
         "", HFILL }},
 
     { &hf_lacpdu_coll_type,
-      { "Collector Information",    "lacp.collectorInfo",
+      { "Collector Information",    "slow.lacp.collectorInfo",
         FT_UINT8,    BASE_HEX,    NULL,    0x0,
         "TLV type = Collector", HFILL }},
 
     { &hf_lacpdu_coll_info_len,
-      { "Collector Information Length",            "lacp.collectorInfoLen",
+      { "Collector Information Length",            "slow.lacp.collectorInfoLen",
         FT_UINT8,    BASE_HEX,    NULL,    0x0,
         "The length of the Collector TLV", HFILL }},
 
     { &hf_lacpdu_coll_max_delay,
-      { "Collector Max Delay",  "lacp.collectorMaxDelay",
+      { "Collector Max Delay",  "slow.lacp.collectorMaxDelay",
         FT_UINT16,    BASE_DEC,    NULL,    0x0,
         "The max delay of the station tx'ing the LACPDU (in tens of usecs)", HFILL }},
 
     { &hf_lacpdu_coll_reserved,
-      { "Reserved",        "lacp.reserved",
+      { "Reserved",        "slow.lacp.coll_reserved",
         FT_BYTES,    BASE_NONE,    NULL,    0x0,
         "", HFILL }},
 
     { &hf_lacpdu_term_type,
-      { "Terminator Information",    "lacp.termInfo",
+      { "Terminator Information",    "slow.lacp.termInfo",
         FT_UINT8,    BASE_HEX,    NULL,    0x0,
         "TLV type = Terminator", HFILL }},
 
     { &hf_lacpdu_term_len,
-      { "Terminator Length",            "lacp.termLen",
+      { "Terminator Length",            "slow.lacp.termLen",
         FT_UINT8,    BASE_HEX,    NULL,    0x0,
         "The length of the Terminator TLV", HFILL }},
 
     { &hf_lacpdu_term_reserved,
-      { "Reserved",        "lacp.reserved",
+      { "Reserved",        "slow.lacp.term_reserved",
         FT_BYTES,    BASE_NONE,    NULL,    0x0,
         "", HFILL }},
 
@@ -2590,32 +2590,32 @@ proto_register_slow_protocols(void)
  */
 
     { &hf_marker_version_number,
-      { "Version Number",    "marker.version",
+      { "Version Number",    "slow.marker.version",
         FT_UINT8,    BASE_HEX,    NULL,    0x0,
         "Identifies the Marker version", HFILL }},
 
     { &hf_marker_tlv_type,
-      { "TLV Type",    "marker.tlvType",
+      { "TLV Type",    "slow.marker.tlvType",
         FT_UINT8,    BASE_HEX,    VALS(marker_vals),    0x0,
         "Marker TLV type", HFILL }},
 
     { &hf_marker_tlv_length,
-      { "TLV Length",            "marker.tlvLen",
+      { "TLV Length",            "slow.marker.tlvLen",
         FT_UINT8,    BASE_HEX,    NULL,    0x0,
         "The length of the Actor TLV", HFILL }},
 
     { &hf_marker_req_port,
-      { "Requester Port",  "marker.requesterPort",
+      { "Requester Port",  "slow.marker.requesterPort",
         FT_UINT16,    BASE_DEC,    NULL,    0x0,
         "The Requester Port", HFILL }},
 
     { &hf_marker_req_system,
-      { "Requester System",  "marker.requesterSystem",
+      { "Requester System",  "slow.marker.requesterSystem",
         FT_ETHER,    BASE_NONE,    NULL,    0x0,
         "The Requester System ID encoded as a MAC address", HFILL }},
 
     { &hf_marker_req_trans_id,
-      { "Requester Transaction ID",  "marker.requesterTransId",
+      { "Requester Transaction ID",  "slow.marker.requesterTransId",
         FT_UINT32,    BASE_DEC,    NULL,    0x0,
         "The Requester Transaction ID", HFILL }},
 
@@ -2623,127 +2623,127 @@ proto_register_slow_protocols(void)
  *  OAMPDU portion
  */
     { &hf_oampdu_flags,
-      { "Flags",    "oam.flags",
+      { "Flags",    "slow.oam.flags",
         FT_UINT16,    BASE_HEX,    NULL,    0x0,
         "The Flags Field", HFILL }},
 
     { &hf_oampdu_flags_link_fault,
-      { "Link Fault",        "oam.flags.linkFault",
+      { "Link Fault",        "slow.oam.flags.linkFault",
         FT_BOOLEAN,    8,        TFS(&falsetrue),    OAMPDU_FLAGS_LINK_FAULT,
         "The PHY detected a fault in the receive direction. True = 1, False = 0", HFILL }},
 
     { &hf_oampdu_flags_dying_gasp,
-      { "Dying Gasp",        "oam.flags.dyingGasp",
+      { "Dying Gasp",        "slow.oam.flags.dyingGasp",
         FT_BOOLEAN,    8,        TFS(&falsetrue),    OAMPDU_FLAGS_DYING_GASP,
         "An unrecoverable local failure occured. True = 1, False = 0", HFILL }},
 
     { &hf_oampdu_flags_critical_event,
-      { "Critical Event",        "oam.flags.criticalEvent",
+      { "Critical Event",        "slow.oam.flags.criticalEvent",
         FT_BOOLEAN,    8,        TFS(&falsetrue),    OAMPDU_FLAGS_CRITICAL_EVENT,
         "A critical event has occurred. True = 1, False = 0", HFILL }},
 
     { &hf_oampdu_flags_local_evaluating,
-      { "Local Evaluating",        "oam.flags.localEvaluating",
+      { "Local Evaluating",        "slow.oam.flags.localEvaluating",
         FT_BOOLEAN,    8,        TFS(&falsetrue),    OAMPDU_FLAGS_LOCAL_EVAL,
         "Local DTE Discovery process in progress. True = 1, False = 0", HFILL }},
 
     { &hf_oampdu_flags_local_stable,
-      { "Local Stable",        "oam.flags.localStable",
+      { "Local Stable",        "slow.oam.flags.localStable",
         FT_BOOLEAN,    8,        TFS(&falsetrue),    OAMPDU_FLAGS_LOCAL_STABLE,
         "Local DTE is Stable. True = 1, False = 0", HFILL }},
 
     { &hf_oampdu_flags_remote_evaluating,
-      { "Remote Evaluating",        "oam.flags.remoteEvaluating",
+      { "Remote Evaluating",        "slow.oam.flags.remoteEvaluating",
         FT_BOOLEAN,    8,        TFS(&falsetrue),    OAMPDU_FLAGS_REMOTE_EVAL,
         "Remote DTE Discovery process in progress. True = 1, False = 0", HFILL }},
 
     { &hf_oampdu_flags_remote_stable,
-      { "Remote Stable",        "oam.flags.remoteStable",
+      { "Remote Stable",        "slow.oam.flags.remoteStable",
         FT_BOOLEAN,    8,        TFS(&falsetrue),    OAMPDU_FLAGS_REMOTE_STABLE,
         "Remote DTE is Stable. True = 1, False = 0", HFILL }},
 
     { &hf_oampdu_code,
-      { "OAMPDU code",    "oam.code",
+      { "OAMPDU code",    "slow.oam.code",
         FT_UINT8,    BASE_HEX,    VALS(code_vals),    0x0,
         "Identifies the TLVs code", HFILL }},
 
     { &hf_oampdu_info_type,
-      { "Type",    "oam.info.type",
+      { "Type",    "slow.oam.info.type",
         FT_UINT8,    BASE_HEX,    VALS(info_type_vals),    0x0,
         "Identifies the TLV type", HFILL }},
 
     { &hf_oampdu_info_len,
-      { "TLV Length",    "oam.info.length",
+      { "TLV Length",    "slow.oam.info.length",
         FT_UINT8,    BASE_DEC,    NULL,    0x0,
         "Identifies the TLVs type", HFILL }},
 
     { &hf_oampdu_info_version,
-      { "TLV Version",    "oam.info.version",
+      { "TLV Version",    "slow.oam.info.version",
         FT_UINT8,    BASE_HEX,    NULL,    0x0,
         "Identifies the TLVs version", HFILL }},
 
     { &hf_oampdu_info_revision,
-      { "TLV Revision",    "oam.info.revision",
+      { "TLV Revision",    "slow.oam.info.revision",
         FT_UINT16,    BASE_DEC,    NULL,    0x0,
         "Identifies the TLVs revision", HFILL }},
 
     { &hf_oampdu_info_state,
-      { "OAM DTE States",    "oam.info.state",
+      { "OAM DTE States",    "slow.oam.info.state",
         FT_UINT8,    BASE_HEX,    NULL,    0x0,
         "OAM DTE State of the Mux and the Parser", HFILL }},
 
     { &hf_oampdu_info_state_parser,
-      { "Parser Action",        "oam.info.state.parser",
+      { "Parser Action",        "slow.oam.info.state.parser",
         FT_UINT8,    BASE_HEX,    VALS(&parser_vals),    0x03,
         "Parser Action", HFILL }},
 
     { &hf_oampdu_info_state_mux,
-      { "Muxiplexer Action",        "oam.info.state.muxiplexer",
+      { "Muxiplexer Action",        "slow.oam.info.state.muxiplexer",
         FT_BOOLEAN,    8,        TFS(&mux),    0x04,
         "Muxiplexer Action", HFILL }},
 
     { &hf_oampdu_info_oamConfig,
-      { "OAM Configuration",    "oam.info.oamConfig",
+      { "OAM Configuration",    "slow.oam.info.oamConfig",
         FT_UINT8,    BASE_HEX,    NULL,    0x0,
         "OAM Configuration", HFILL }},
 
     { &hf_oampdu_info_oamConfig_mode,
-      { "OAM Mode",        "oam.info.oamConfig.mode",
+      { "OAM Mode",        "slow.oam.info.oamConfig.mode",
         FT_BOOLEAN,    8,        TFS(&oam_mode),    OAMPDU_INFO_CONFIG_MODE,
         "", HFILL }},
 
     { &hf_oampdu_info_oamConfig_uni,
-      { "Unidirectional support",        "oam.flags.dyingGasp",
+      { "Unidirectional support",        "slow.oam.flags.dyingGasp",
         FT_BOOLEAN,    8,        TFS(&oam_uni),    OAMPDU_INFO_CONFIG_UNI,
         "Unidirectional support", HFILL }},
 
     { &hf_oampdu_info_oamConfig_lpbk,
-      { "Loopback support",        "oam.flags.criticalEvent",
+      { "Loopback support",        "slow.oam.flags.criticalEvent",
         FT_BOOLEAN,    8,        TFS(&oam_lpbk),    OAMPDU_INFO_CONFIG_LPBK,
         "Loopback support", HFILL }},
 
     { &hf_oampdu_info_oamConfig_event,
-      { "Link Events support",        "oam.flags.localEvaluating",
+      { "Link Events support",        "slow.oam.flags.localEvaluating",
         FT_BOOLEAN,    8,        TFS(&oam_event),    OAMPDU_INFO_CONFIG_EVENT,
         "Link Events support", HFILL }},
 
     { &hf_oampdu_info_oamConfig_var,
-      { "Variable Retrieval",        "oam.flags.localStable",
+      { "Variable Retrieval",        "slow.oam.flags.localStable",
         FT_BOOLEAN,    8,        TFS(&oam_var),    OAMPDU_INFO_CONFIG_VAR,
         "Variable Retrieval support", HFILL }},
 
     { &hf_oampdu_info_oampduConfig,
-      { "Max OAMPDU Size",    "oam.info.oampduConfig",
+      { "Max OAMPDU Size",    "slow.oam.info.oampduConfig",
         FT_UINT16,    BASE_DEC,    NULL,    0x0,
         "OAMPDU Configuration", HFILL }},
 
     { &hf_oampdu_info_oui,
-      { "Organizationally Unique Identifier", "oam.info.oui",
+      { "Organizationally Unique Identifier", "slow.oam.info.oui",
         FT_BYTES,    BASE_NONE,    NULL,    0x0,
         "", HFILL }},
 
     { &hf_oampdu_info_vendor,
-      { "Vendor Specific Information", "oam.info.vendor",
+      { "Vendor Specific Information", "slow.oam.info.vendor",
         FT_BYTES,    BASE_NONE,    NULL,    0x0,
         "", HFILL }},
 
@@ -2751,183 +2751,183 @@ proto_register_slow_protocols(void)
      * Event notification definitions
      */
     { &hf_oampdu_event_sequence,
-      { "Sequence Number",    "oam.event.sequence",
+      { "Sequence Number",    "slow.oam.event.sequence",
         FT_UINT16,    BASE_DEC,    NULL,    0x0,
         "Identifies the Event Notification TLVs", HFILL }},
 
     { &hf_oampdu_event_type,
-      { "Event Type",    "oam.event.type",
+      { "Event Type",    "slow.oam.event.type",
         FT_UINT8,    BASE_HEX,    VALS(event_type_vals),    0x0,
         "Identifies the TLV type", HFILL }},
 
     { &hf_oampdu_event_length,
-      { "Event Length",    "oam.event.length",
+      { "Event Length",    "slow.oam.event.length",
         FT_UINT8,    BASE_HEX,    NULL,    0x0,
         "This field indicates the length in octets of the TLV-tuple", HFILL }},
 
     { &hf_oampdu_event_timeStamp,
-      { "Event Timestamp (100ms)",    "oam.event.timestamp",
+      { "Event Timestamp (100ms)",    "slow.oam.event.timestamp",
         FT_UINT16,    BASE_DEC,    NULL,    0x0,
         "Event Time Stamp in term of 100 ms intervals", HFILL }},
 
     /* Errored Symbol Period Event TLV */
     { &hf_oampdu_event_espeWindow,
-      { "Errored Symbol Window",    "oam.event.espeWindow",
+      { "Errored Symbol Window",    "slow.oam.event.espeWindow",
         FT_UINT64,    BASE_DEC,    NULL,    0x0,
         "Number of symbols in the period", HFILL }},
 
     { &hf_oampdu_event_espeThreshold,
-      { "Errored Symbol Threshold",    "oam.event.espeThreshold",
+      { "Errored Symbol Threshold",    "slow.oam.event.espeThreshold",
         FT_UINT64,    BASE_DEC,    NULL,    0x0,
         "Number of symbols required to generate the Event", HFILL }},
 
     { &hf_oampdu_event_espeErrors,
-      { "Errored Symbols",    "oam.event.espeErrors",
+      { "Errored Symbols",    "slow.oam.event.espeErrors",
         FT_UINT64,    BASE_DEC,    NULL,    0x0,
         "Number of symbols in error", HFILL }},
 
     { &hf_oampdu_event_espeTotalErrors,
-      { "Error Running Total",    "oam.event.espeTotalErrors",
+      { "Error Running Total",    "slow.oam.event.espeTotalErrors",
         FT_UINT64,    BASE_DEC,    NULL,    0x0,
         "Number of symbols in error since reset of the sublayer", HFILL }},
 
     { &hf_oampdu_event_espeTotalEvents,
-      { "Event Running Total",    "oam.event.espeTotalEvents",
+      { "Event Running Total",    "slow.oam.event.espeTotalEvents",
         FT_UINT32,    BASE_DEC,    NULL,    0x0,
         "Total Event generated since reset of the sublayer", HFILL }},
 
     /* Errored Frame Event TLV */
     { &hf_oampdu_event_efeWindow,
-      { "Errored Frame Window",    "oam.event.efeWindow",
+      { "Errored Frame Window",    "slow.oam.event.efeWindow",
         FT_UINT16,    BASE_DEC,    NULL,    0x0,
         "Number of symbols in the period", HFILL }},
 
     { &hf_oampdu_event_efeThreshold,
-      { "Errored Frame Threshold",    "oam.event.efeThreshold",
+      { "Errored Frame Threshold",    "slow.oam.event.efeThreshold",
         FT_UINT32,    BASE_DEC,    NULL,    0x0,
         "Number of frames required to generate the Event", HFILL }},
 
     { &hf_oampdu_event_efeErrors,
-      { "Errored Frames",    "oam.event.efeErrors",
+      { "Errored Frames",    "slow.oam.event.efeErrors",
         FT_UINT32,    BASE_DEC,    NULL,    0x0,
         "Number of symbols in error", HFILL }},
 
     { &hf_oampdu_event_efeTotalErrors,
-      { "Error Running Total",    "oam.event.efeTotalErrors",
+      { "Error Running Total",    "slow.oam.event.efeTotalErrors",
         FT_UINT64,    BASE_DEC,    NULL,    0x0,
         "Number of frames in error since reset of the sublayer", HFILL }},
 
     { &hf_oampdu_event_efeTotalEvents,
-      { "Event Running Total",    "oam.event.efeTotalEvents",
+      { "Event Running Total",    "slow.oam.event.efeTotalEvents",
         FT_UINT32,    BASE_DEC,    NULL,    0x0,
         "Total Event generated since reset of the sublayer", HFILL }},
 
     /* Errored Frame Period Event TLV */
     { &hf_oampdu_event_efpeWindow,
-      { "Errored Frame Window",    "oam.event.efpeWindow",
+      { "Errored Frame Window",    "slow.oam.event.efpeWindow",
         FT_UINT32,    BASE_DEC,    NULL,    0x0,
         "Number of frame in error during the period", HFILL }},
 
     { &hf_oampdu_event_efpeThreshold,
-      { "Errored Frame Threshold",    "oam.event.efpeThreshold",
+      { "Errored Frame Threshold",    "slow.oam.event.efpeThreshold",
         FT_UINT32,    BASE_DEC,    NULL,    0x0,
         "Number of frames required to generate the Event", HFILL }},
 
     { &hf_oampdu_event_efpeErrors,
-      { "Errored Frames",    "oam.event.efeErrors",
+      { "Errored Frames",    "slow.oam.event.efeErrors",
         FT_UINT32,    BASE_DEC,    NULL,    0x0,
         "Number of symbols in error", HFILL }},
 
     { &hf_oampdu_event_efpeTotalErrors,
-      { "Error Running Total",    "oam.event.efpeTotalErrors",
+      { "Error Running Total",    "slow.oam.event.efpeTotalErrors",
         FT_UINT64,    BASE_DEC,    NULL,    0x0,
         "Number of frames in error since reset of the sublayer", HFILL }},
 
     { &hf_oampdu_event_efpeTotalEvents,
-      { "Event Running Total",    "oam.event.efpeTotalEvents",
+      { "Event Running Total",    "slow.oam.event.efpeTotalEvents",
         FT_UINT32,    BASE_DEC,    NULL,    0x0,
         "Total Event generated since reset of the sublayer", HFILL }},
 
     /* Errored Frame Second Summary Event TLV */
     { &hf_oampdu_event_efsseWindow,
-      { "Errored Frame Window",    "oam.event.efsseWindow",
+      { "Errored Frame Window",    "slow.oam.event.efsseWindow",
         FT_UINT16,    BASE_DEC,    NULL,    0x0,
         "Number of frame in error during the period", HFILL }},
 
     { &hf_oampdu_event_efsseThreshold,
-      { "Errored Frame Threshold",    "oam.event.efsseThreshold",
+      { "Errored Frame Threshold",    "slow.oam.event.efsseThreshold",
         FT_UINT16,    BASE_DEC,    NULL,    0x0,
         "Number of frames required to generate the Event", HFILL }},
 
     { &hf_oampdu_event_efsseErrors,
-      { "Errored Frames",    "oam.event.efeErrors",
+      { "Errored Frames",    "slow.oam.event.efeErrors",
         FT_UINT16,    BASE_DEC,    NULL,    0x0,
         "Number of symbols in error", HFILL }},
 
     { &hf_oampdu_event_efsseTotalErrors,
-      { "Error Running Total",    "oam.event.efsseTotalErrors",
+      { "Error Running Total",    "slow.oam.event.efsseTotalErrors",
         FT_UINT32,    BASE_DEC,    NULL,    0x0,
         "Number of frames in error since reset of the sublayer", HFILL }},
 
     { &hf_oampdu_event_efsseTotalEvents,
-      { "Event Running Total",    "oam.event.efsseTotalEvents",
+      { "Event Running Total",    "slow.oam.event.efsseTotalEvents",
         FT_UINT32,    BASE_DEC,    NULL,    0x0,
         "Total Event generated since reset of the sublayer", HFILL }},
 
     /* Variable request and response definitions*/
     { &hf_oampdu_variable_branch,
-      { "Branch",    "oam.variable.branch",
+      { "Branch",    "slow.oam.variable.branch",
         FT_UINT8,    BASE_HEX,    VALS(branch_vals),    0x0,
         "Variable Branch, derived from the CMIP protocol in Annex 30A", HFILL }},
 
     { &hf_oampdu_variable_object,
-      { "Leaf",    "oam.variable.object",
+      { "Leaf",    "slow.oam.variable.object",
         FT_UINT16,    BASE_HEX,    VALS(object_vals),    0x0,
         "Object, derived from the CMIP protocol in Annex 30A", HFILL }},
 
     { &hf_oampdu_variable_package,
-      { "Leaf",    "oam.variable.package",
+      { "Leaf",    "slow.oam.variable.package",
         FT_UINT16,    BASE_HEX,    VALS(package_vals),    0x0,
         "Package, derived from the CMIP protocol in Annex 30A", HFILL }},
 
     { &hf_oampdu_variable_binding,
-      { "Leaf",    "oam.variable.binding",
+      { "Leaf",    "slow.oam.variable.binding",
         FT_UINT16,    BASE_HEX,    VALS(binding_vals),    0x0,
         "Binding, derived from the CMIP protocol in Annex 30A", HFILL }},
 
     { &hf_oampdu_variable_attribute,
-      { "Leaf",    "oam.variable.attribute",
+      { "Leaf",    "slow.oam.variable.attribute",
         FT_UINT16,    BASE_HEX,    VALS(attribute_vals),    0x0,
         "Attribute, derived from the CMIP protocol in Annex 30A", HFILL }},
 
     { &hf_oampdu_variable_width,
-      { "Variable Width",    "oam.variable.width",
+      { "Variable Width",    "slow.oam.variable.width",
         FT_UINT8,    BASE_DEC,    NULL,    0x0,
         "Width", HFILL }},
 
     { &hf_oampdu_variable_indication,
-      { "Variable indication",    "oam.variable.indication",
+      { "Variable indication",    "slow.oam.variable.indication",
         FT_UINT8,    BASE_HEX,    VALS(indication_vals),    0x0,
         "Variable indication", HFILL }},
 
     { &hf_oampdu_variable_value,
-      { "Variable Value",    "oam.variable.value",
+      { "Variable Value",    "slow.oam.variable.value",
         FT_BYTES,    BASE_HEX,    NULL,    0x0,
         "Value", HFILL }},
 
     /* Loopback Control definitions*/
     { &hf_oampdu_lpbk,
-      { "Commands", "oam.lpbk.commands",
+      { "Commands", "slow.oam.lpbk.commands",
         FT_UINT8,    BASE_HEX,    NULL,    0x0,
         "The List of Loopback Commands", HFILL }},
 
     { &hf_oampdu_lpbk_enable,
-      { "Enable Remote Loopback", "oam.lpbk.commands.enable",
+      { "Enable Remote Loopback", "slow.oam.lpbk.commands.enable",
         FT_BOOLEAN,    8,        NULL,    OAMPDU_LPBK_ENABLE,
         "Enable Remote Loopback Command", HFILL }},
 
     { &hf_oampdu_lpbk_disable,
-      { "Disable Remote Loopback", "oam.lpbk.commands.disable",
+      { "Disable Remote Loopback", "slow.oam.lpbk.commands.disable",
         FT_BOOLEAN,    8,        NULL,    OAMPDU_LPBK_DISABLE,
         "Disable Remote Loopback Command", HFILL }},
   };