ASN.1 dissectors regenerated with new asn2wrs to get updated field blurb
authorkukosa <kukosa@f5534014-38df-0310-8fa8-9805f1628bb7>
Wed, 16 Aug 2006 05:58:39 +0000 (05:58 +0000)
committerkukosa <kukosa@f5534014-38df-0310-8fa8-9805f1628bb7>
Wed, 16 Aug 2006 05:58:39 +0000 (05:58 +0000)
git-svn-id: http://anonsvn.wireshark.org/wireshark/trunk@18921 f5534014-38df-0310-8fa8-9805f1628bb7

61 files changed:
epan/dissectors/packet-MAP_DialoguePDU.c
epan/dissectors/packet-acp133.c
epan/dissectors/packet-acse.c
epan/dissectors/packet-camel.c
epan/dissectors/packet-cdt.c
epan/dissectors/packet-cdt.h
epan/dissectors/packet-cmip.c
epan/dissectors/packet-cmp.c
epan/dissectors/packet-cms.c
epan/dissectors/packet-crmf.c
epan/dissectors/packet-dap.c
epan/dissectors/packet-disp.c
epan/dissectors/packet-dop.c
epan/dissectors/packet-dsp.c
epan/dissectors/packet-ess.c
epan/dissectors/packet-ftam.c
epan/dissectors/packet-ftbp.c
epan/dissectors/packet-gnm.c
epan/dissectors/packet-gsm_map.c
epan/dissectors/packet-gsm_ss.c
epan/dissectors/packet-h225.c
epan/dissectors/packet-h235.c
epan/dissectors/packet-h245.c
epan/dissectors/packet-h248.c
epan/dissectors/packet-h450.c
epan/dissectors/packet-inap.c
epan/dissectors/packet-ldap.c
epan/dissectors/packet-logotypecertextn.c
epan/dissectors/packet-mms.c
epan/dissectors/packet-nbap.c
epan/dissectors/packet-ns_cert_exts.c
epan/dissectors/packet-ocsp.c
epan/dissectors/packet-pkcs1.c
epan/dissectors/packet-pkinit.c
epan/dissectors/packet-pkix1explicit.c
epan/dissectors/packet-pkix1implicit.c
epan/dissectors/packet-pkixproxy.c
epan/dissectors/packet-pkixqualified.c
epan/dissectors/packet-pkixtsp.c
epan/dissectors/packet-pres.c
epan/dissectors/packet-ranap.c
epan/dissectors/packet-rnsap.c
epan/dissectors/packet-ros.c
epan/dissectors/packet-rrlp.c
epan/dissectors/packet-rtse.c
epan/dissectors/packet-s4406.c
epan/dissectors/packet-smrse.c
epan/dissectors/packet-snmp.c
epan/dissectors/packet-spnego.c
epan/dissectors/packet-tcap.c
epan/dissectors/packet-ulp.c
epan/dissectors/packet-umts_rrc.c
epan/dissectors/packet-umts_rrc_ies.c
epan/dissectors/packet-umts_rrc_pdu_def.c
epan/dissectors/packet-wlancertextn.c
epan/dissectors/packet-x411.c
epan/dissectors/packet-x420.c
epan/dissectors/packet-x509af.c
epan/dissectors/packet-x509ce.c
epan/dissectors/packet-x509if.c
epan/dissectors/packet-x509sat.c

index 2575c383e3a830dc535afc60663b1750f2caad4e..0bcda0ec6832add2de7d7edf0377bd6810519320 100644 (file)
@@ -433,83 +433,83 @@ void proto_register_MAP_DialoguePDU(void) {
     { &hf_MAP_DialoguePDU_map_open,
       { "map-open", "MAP_DialoguePDU.map_open",
         FT_NONE, BASE_NONE, NULL, 0,
-        "MAP-DialoguePDU/map-open", HFILL }},
+        "MAP_DialoguePDU.MAP_OpenInfo", HFILL }},
     { &hf_MAP_DialoguePDU_map_accept,
       { "map-accept", "MAP_DialoguePDU.map_accept",
         FT_NONE, BASE_NONE, NULL, 0,
-        "MAP-DialoguePDU/map-accept", HFILL }},
+        "MAP_DialoguePDU.MAP_AcceptInfo", HFILL }},
     { &hf_MAP_DialoguePDU_map_close,
       { "map-close", "MAP_DialoguePDU.map_close",
         FT_NONE, BASE_NONE, NULL, 0,
-        "MAP-DialoguePDU/map-close", HFILL }},
+        "MAP_DialoguePDU.MAP_CloseInfo", HFILL }},
     { &hf_MAP_DialoguePDU_map_refuse,
       { "map-refuse", "MAP_DialoguePDU.map_refuse",
         FT_NONE, BASE_NONE, NULL, 0,
-        "MAP-DialoguePDU/map-refuse", HFILL }},
+        "MAP_DialoguePDU.MAP_RefuseInfo", HFILL }},
     { &hf_MAP_DialoguePDU_map_userAbort,
       { "map-userAbort", "MAP_DialoguePDU.map_userAbort",
         FT_NONE, BASE_NONE, NULL, 0,
-        "MAP-DialoguePDU/map-userAbort", HFILL }},
+        "MAP_DialoguePDU.MAP_UserAbortInfo", HFILL }},
     { &hf_MAP_DialoguePDU_map_providerAbort,
       { "map-providerAbort", "MAP_DialoguePDU.map_providerAbort",
         FT_NONE, BASE_NONE, NULL, 0,
-        "MAP-DialoguePDU/map-providerAbort", HFILL }},
+        "MAP_DialoguePDU.MAP_ProviderAbortInfo", HFILL }},
     { &hf_MAP_DialoguePDU_destinationReference,
       { "destinationReference", "MAP_DialoguePDU.destinationReference",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "MAP-OpenInfo/destinationReference", HFILL }},
+        "gsm_map.AddressString", HFILL }},
     { &hf_MAP_DialoguePDU_originationReference,
       { "originationReference", "MAP_DialoguePDU.originationReference",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "MAP-OpenInfo/originationReference", HFILL }},
+        "gsm_map.AddressString", HFILL }},
     { &hf_MAP_DialoguePDU_extensionContainer,
       { "extensionContainer", "MAP_DialoguePDU.extensionContainer",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "gsm_map.ExtensionContainer", HFILL }},
     { &hf_MAP_DialoguePDU_reason,
       { "reason", "MAP_DialoguePDU.reason",
         FT_UINT32, BASE_DEC, VALS(MAP_DialoguePDU_Reason_vals), 0,
-        "MAP-RefuseInfo/reason", HFILL }},
+        "MAP_DialoguePDU.Reason", HFILL }},
     { &hf_MAP_DialoguePDU_alternativeApplicationContext,
       { "alternativeApplicationContext", "MAP_DialoguePDU.alternativeApplicationContext",
         FT_OID, BASE_NONE, NULL, 0,
-        "MAP-RefuseInfo/alternativeApplicationContext", HFILL }},
+        "MAP_DialoguePDU.OBJECT_IDENTIFIER", HFILL }},
     { &hf_MAP_DialoguePDU_map_UserAbortChoice,
       { "map-UserAbortChoice", "MAP_DialoguePDU.map_UserAbortChoice",
         FT_UINT32, BASE_DEC, VALS(MAP_DialoguePDU_MAP_UserAbortChoice_vals), 0,
-        "MAP-UserAbortInfo/map-UserAbortChoice", HFILL }},
+        "MAP_DialoguePDU.MAP_UserAbortChoice", HFILL }},
     { &hf_MAP_DialoguePDU_userSpecificReason,
       { "userSpecificReason", "MAP_DialoguePDU.userSpecificReason",
         FT_NONE, BASE_NONE, NULL, 0,
-        "MAP-UserAbortChoice/userSpecificReason", HFILL }},
+        "MAP_DialoguePDU.NULL", HFILL }},
     { &hf_MAP_DialoguePDU_userResourceLimitation,
       { "userResourceLimitation", "MAP_DialoguePDU.userResourceLimitation",
         FT_NONE, BASE_NONE, NULL, 0,
-        "MAP-UserAbortChoice/userResourceLimitation", HFILL }},
+        "MAP_DialoguePDU.NULL", HFILL }},
     { &hf_MAP_DialoguePDU_resourceUnavailable,
       { "resourceUnavailable", "MAP_DialoguePDU.resourceUnavailable",
         FT_UINT32, BASE_DEC, VALS(MAP_DialoguePDU_ResourceUnavailableReason_vals), 0,
-        "MAP-UserAbortChoice/resourceUnavailable", HFILL }},
+        "MAP_DialoguePDU.ResourceUnavailableReason", HFILL }},
     { &hf_MAP_DialoguePDU_applicationProcedureCancellation,
       { "applicationProcedureCancellation", "MAP_DialoguePDU.applicationProcedureCancellation",
         FT_UINT32, BASE_DEC, VALS(MAP_DialoguePDU_ProcedureCancellationReason_vals), 0,
-        "MAP-UserAbortChoice/applicationProcedureCancellation", HFILL }},
+        "MAP_DialoguePDU.ProcedureCancellationReason", HFILL }},
     { &hf_MAP_DialoguePDU_map_ProviderAbortReason,
       { "map-ProviderAbortReason", "MAP_DialoguePDU.map_ProviderAbortReason",
         FT_UINT32, BASE_DEC, VALS(MAP_DialoguePDU_MAP_ProviderAbortReason_vals), 0,
-        "MAP-ProviderAbortInfo/map-ProviderAbortReason", HFILL }},
+        "MAP_DialoguePDU.MAP_ProviderAbortReason", HFILL }},
     { &hf_MAP_DialoguePDU_encapsulatedAC,
       { "encapsulatedAC", "MAP_DialoguePDU.encapsulatedAC",
         FT_OID, BASE_NONE, NULL, 0,
-        "MAP-ProtectedDialoguePDU/encapsulatedAC", HFILL }},
+        "MAP_DialoguePDU.OBJECT_IDENTIFIER", HFILL }},
     { &hf_MAP_DialoguePDU_securityHeader,
       { "securityHeader", "MAP_DialoguePDU.securityHeader",
         FT_NONE, BASE_NONE, NULL, 0,
-        "MAP-ProtectedDialoguePDU/securityHeader", HFILL }},
+        "gsm_map.SecurityHeader", HFILL }},
     { &hf_MAP_DialoguePDU_protectedPayload,
       { "protectedPayload", "MAP_DialoguePDU.protectedPayload",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "MAP-ProtectedDialoguePDU/protectedPayload", HFILL }},
+        "gsm_map.ProtectedPayload", HFILL }},
 
 /*--- End of included file: packet-MAP_DialoguePDU-hfarr.c ---*/
 #line 64 "packet-MAP-DialoguePDU-template.c"
index 3134e8575ae7350ec9169b0ffa8f0dbf6e76c119..63bb11898cf3ec0bf8c6a598af9ce0d775a9cbaf 100644 (file)
@@ -1171,299 +1171,299 @@ void proto_register_acp133(void) {
     { &hf_acp133_ACPPreferredDelivery_PDU,
       { "ACPPreferredDelivery", "acp133.ACPPreferredDelivery",
         FT_UINT32, BASE_DEC, VALS(acp133_ACPPreferredDelivery_vals), 0,
-        "ACPPreferredDelivery", HFILL }},
+        "acp133.ACPPreferredDelivery", HFILL }},
     { &hf_acp133_ALType_PDU,
       { "ALType", "acp133.ALType",
         FT_INT32, BASE_DEC, VALS(acp133_ALType_vals), 0,
-        "ALType", HFILL }},
+        "acp133.ALType", HFILL }},
     { &hf_acp133_Community_PDU,
       { "Community", "acp133.Community",
         FT_UINT32, BASE_DEC, VALS(acp133_Community_vals), 0,
-        "Community", HFILL }},
+        "acp133.Community", HFILL }},
     { &hf_acp133_OnSupported_PDU,
       { "OnSupported", "acp133.OnSupported",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "OnSupported", HFILL }},
+        "acp133.OnSupported", HFILL }},
     { &hf_acp133_ACPLegacyFormat_PDU,
       { "ACPLegacyFormat", "acp133.ACPLegacyFormat",
         FT_INT32, BASE_DEC, VALS(acp133_ACPLegacyFormat_vals), 0,
-        "ACPLegacyFormat", HFILL }},
+        "acp133.ACPLegacyFormat", HFILL }},
     { &hf_acp133_Addressees_PDU,
       { "Addressees", "acp133.Addressees",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Addressees", HFILL }},
+        "acp133.Addressees", HFILL }},
     { &hf_acp133_Classification_PDU,
       { "Classification", "acp133.Classification",
         FT_UINT32, BASE_DEC, VALS(acp133_Classification_vals), 0,
-        "Classification", HFILL }},
+        "acp133.Classification", HFILL }},
     { &hf_acp133_DistributionCode_PDU,
       { "DistributionCode", "acp133.DistributionCode",
         FT_STRING, BASE_NONE, NULL, 0,
-        "DistributionCode", HFILL }},
+        "acp133.DistributionCode", HFILL }},
     { &hf_acp133_JPEG_PDU,
       { "JPEG", "acp133.JPEG",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "JPEG", HFILL }},
+        "acp133.JPEG", HFILL }},
     { &hf_acp133_MonthlyUKMs_PDU,
       { "MonthlyUKMs", "acp133.MonthlyUKMs",
         FT_NONE, BASE_NONE, NULL, 0,
-        "MonthlyUKMs", HFILL }},
+        "acp133.MonthlyUKMs", HFILL }},
     { &hf_acp133_Remarks_PDU,
       { "Remarks", "acp133.Remarks",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Remarks", HFILL }},
+        "acp133.Remarks", HFILL }},
     { &hf_acp133_RIParameters_PDU,
       { "RIParameters", "acp133.RIParameters",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RIParameters", HFILL }},
+        "acp133.RIParameters", HFILL }},
     { &hf_acp133_Kmid_PDU,
       { "Kmid", "acp133.Kmid",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "Kmid", HFILL }},
+        "acp133.Kmid", HFILL }},
     { &hf_acp133_MLReceiptPolicy_PDU,
       { "MLReceiptPolicy", "acp133.MLReceiptPolicy",
         FT_UINT32, BASE_DEC, VALS(acp133_MLReceiptPolicy_vals), 0,
-        "MLReceiptPolicy", HFILL }},
+        "acp133.MLReceiptPolicy", HFILL }},
     { &hf_acp133_DLSubmitPermission_PDU,
       { "DLSubmitPermission", "acp133.DLSubmitPermission",
         FT_UINT32, BASE_DEC, VALS(acp133_DLSubmitPermission_vals), 0,
-        "DLSubmitPermission", HFILL }},
+        "acp133.DLSubmitPermission", HFILL }},
     { &hf_acp133_DLPolicy_PDU,
       { "DLPolicy", "acp133.DLPolicy",
         FT_NONE, BASE_NONE, NULL, 0,
-        "DLPolicy", HFILL }},
+        "acp133.DLPolicy", HFILL }},
     { &hf_acp133_AddressCapabilities_PDU,
       { "AddressCapabilities", "acp133.AddressCapabilities",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AddressCapabilities", HFILL }},
+        "acp133.AddressCapabilities", HFILL }},
     { &hf_acp133_Capability_PDU,
       { "Capability", "acp133.Capability",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Capability", HFILL }},
+        "acp133.Capability", HFILL }},
     { &hf_acp133_Addressees_item,
       { "Item", "acp133.Addressees_item",
         FT_STRING, BASE_NONE, NULL, 0,
-        "Addressees/_item", HFILL }},
+        "acp133.PrintableString_SIZE_1_55", HFILL }},
     { &hf_acp133_ukm_entries,
       { "ukm-entries", "acp133.ukm_entries",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "MonthlyUKMs/ukm-entries", HFILL }},
+        "acp133.SEQUENCE_OF_UKMEntry", HFILL }},
     { &hf_acp133_ukm_entries_item,
       { "Item", "acp133.ukm_entries_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "MonthlyUKMs/ukm-entries/_item", HFILL }},
+        "acp133.UKMEntry", HFILL }},
     { &hf_acp133_algorithm_identifier,
       { "algorithm-identifier", "acp133.algorithm_identifier",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "x509af.AlgorithmIdentifier", HFILL }},
     { &hf_acp133_encrypted,
       { "encrypted", "acp133.encrypted",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "MonthlyUKMs/encrypted", HFILL }},
+        "acp133.BIT_STRING", HFILL }},
     { &hf_acp133_Remarks_item,
       { "Item", "acp133.Remarks_item",
         FT_STRING, BASE_NONE, NULL, 0,
-        "Remarks/_item", HFILL }},
+        "acp133.PrintableString", HFILL }},
     { &hf_acp133_rI,
       { "rI", "acp133.rI",
         FT_STRING, BASE_NONE, NULL, 0,
-        "RIParameters/rI", HFILL }},
+        "acp133.PrintableString", HFILL }},
     { &hf_acp133_rIType,
       { "rIType", "acp133.rIType",
         FT_UINT32, BASE_DEC, VALS(acp133_T_rIType_vals), 0,
-        "RIParameters/rIType", HFILL }},
+        "acp133.T_rIType", HFILL }},
     { &hf_acp133_minimize,
       { "minimize", "acp133.minimize",
         FT_BOOLEAN, 8, NULL, 0,
-        "RIParameters/minimize", HFILL }},
+        "acp133.BOOLEAN", HFILL }},
     { &hf_acp133_sHD,
       { "sHD", "acp133.sHD",
         FT_STRING, BASE_NONE, NULL, 0,
-        "RIParameters/sHD", HFILL }},
+        "acp133.PrintableString", HFILL }},
     { &hf_acp133_classification,
       { "classification", "acp133.classification",
         FT_UINT32, BASE_DEC, VALS(acp133_Classification_vals), 0,
-        "RIParameters/classification", HFILL }},
+        "acp133.Classification", HFILL }},
     { &hf_acp133_tag,
       { "tag", "acp133.tag",
         FT_NONE, BASE_NONE, NULL, 0,
-        "UKMEntry/tag", HFILL }},
+        "acp133.PairwiseTag", HFILL }},
     { &hf_acp133_ukm,
       { "ukm", "acp133.ukm",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "UKMEntry/ukm", HFILL }},
+        "acp133.OCTET_STRING", HFILL }},
     { &hf_acp133_kmid,
       { "kmid", "acp133.kmid",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PairwiseTag/kmid", HFILL }},
+        "acp133.Kmid", HFILL }},
     { &hf_acp133_edition,
       { "edition", "acp133.edition",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PairwiseTag/edition", HFILL }},
+        "acp133.INTEGER", HFILL }},
     { &hf_acp133_date,
       { "date", "acp133.date",
         FT_STRING, BASE_NONE, NULL, 0,
-        "PairwiseTag/date", HFILL }},
+        "acp133.UTCTime", HFILL }},
     { &hf_acp133_none,
       { "none", "acp133.none",
         FT_NONE, BASE_NONE, NULL, 0,
-        "MLReceiptPolicy/none", HFILL }},
+        "acp133.NULL", HFILL }},
     { &hf_acp133_insteadOf,
       { "insteadOf", "acp133.insteadOf",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "MLReceiptPolicy/insteadOf", HFILL }},
+        "acp133.SEQUENCE_OF_GeneralNames", HFILL }},
     { &hf_acp133_insteadOf_item,
       { "Item", "acp133.insteadOf_item",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "MLReceiptPolicy/insteadOf/_item", HFILL }},
+        "x509ce.GeneralNames", HFILL }},
     { &hf_acp133_inAdditionTo,
       { "inAdditionTo", "acp133.inAdditionTo",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "MLReceiptPolicy/inAdditionTo", HFILL }},
+        "acp133.SEQUENCE_OF_GeneralNames", HFILL }},
     { &hf_acp133_inAdditionTo_item,
       { "Item", "acp133.inAdditionTo_item",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "MLReceiptPolicy/inAdditionTo/_item", HFILL }},
+        "x509ce.GeneralNames", HFILL }},
     { &hf_acp133_individual,
       { "individual", "acp133.individual",
         FT_NONE, BASE_NONE, NULL, 0,
-        "DLSubmitPermission/individual", HFILL }},
+        "x411.ORName", HFILL }},
     { &hf_acp133_member_of_dl,
       { "member-of-dl", "acp133.member_of_dl",
         FT_NONE, BASE_NONE, NULL, 0,
-        "DLSubmitPermission/member-of-dl", HFILL }},
+        "x411.ORName", HFILL }},
     { &hf_acp133_pattern_match,
       { "pattern-match", "acp133.pattern_match",
         FT_NONE, BASE_NONE, NULL, 0,
-        "DLSubmitPermission/pattern-match", HFILL }},
+        "acp133.ORNamePattern", HFILL }},
     { &hf_acp133_member_of_group,
       { "member-of-group", "acp133.member_of_group",
         FT_UINT32, BASE_DEC, VALS(x509if_Name_vals), 0,
-        "DLSubmitPermission/member-of-group", HFILL }},
+        "x509if.Name", HFILL }},
     { &hf_acp133_report_propagation,
       { "report-propagation", "acp133.report_propagation",
         FT_INT32, BASE_DEC, VALS(acp133_T_report_propagation_vals), 0,
-        "DLPolicy/report-propagation", HFILL }},
+        "acp133.T_report_propagation", HFILL }},
     { &hf_acp133_report_from_dl,
       { "report-from-dl", "acp133.report_from_dl",
         FT_INT32, BASE_DEC, VALS(acp133_T_report_from_dl_vals), 0,
-        "DLPolicy/report-from-dl", HFILL }},
+        "acp133.T_report_from_dl", HFILL }},
     { &hf_acp133_originating_MTA_report,
       { "originating-MTA-report", "acp133.originating_MTA_report",
         FT_INT32, BASE_DEC, VALS(acp133_T_originating_MTA_report_vals), 0,
-        "DLPolicy/originating-MTA-report", HFILL }},
+        "acp133.T_originating_MTA_report", HFILL }},
     { &hf_acp133_originator_report,
       { "originator-report", "acp133.originator_report",
         FT_INT32, BASE_DEC, VALS(acp133_T_originator_report_vals), 0,
-        "DLPolicy/originator-report", HFILL }},
+        "acp133.T_originator_report", HFILL }},
     { &hf_acp133_return_of_content,
       { "return-of-content", "acp133.return_of_content",
         FT_UINT32, BASE_DEC, VALS(acp133_T_return_of_content_vals), 0,
-        "DLPolicy/return-of-content", HFILL }},
+        "acp133.T_return_of_content", HFILL }},
     { &hf_acp133_priority,
       { "priority", "acp133.priority",
         FT_INT32, BASE_DEC, VALS(acp133_T_priority_vals), 0,
-        "DLPolicy/priority", HFILL }},
+        "acp133.T_priority", HFILL }},
     { &hf_acp133_disclosure_of_other_recipients,
       { "disclosure-of-other-recipients", "acp133.disclosure_of_other_recipients",
         FT_UINT32, BASE_DEC, VALS(acp133_T_disclosure_of_other_recipients_vals), 0,
-        "DLPolicy/disclosure-of-other-recipients", HFILL }},
+        "acp133.T_disclosure_of_other_recipients", HFILL }},
     { &hf_acp133_implicit_conversion_prohibited,
       { "implicit-conversion-prohibited", "acp133.implicit_conversion_prohibited",
         FT_UINT32, BASE_DEC, VALS(acp133_T_implicit_conversion_prohibited_vals), 0,
-        "DLPolicy/implicit-conversion-prohibited", HFILL }},
+        "acp133.T_implicit_conversion_prohibited", HFILL }},
     { &hf_acp133_conversion_with_loss_prohibited,
       { "conversion-with-loss-prohibited", "acp133.conversion_with_loss_prohibited",
         FT_UINT32, BASE_DEC, VALS(acp133_T_conversion_with_loss_prohibited_vals), 0,
-        "DLPolicy/conversion-with-loss-prohibited", HFILL }},
+        "acp133.T_conversion_with_loss_prohibited", HFILL }},
     { &hf_acp133_further_dl_expansion_allowed,
       { "further-dl-expansion-allowed", "acp133.further_dl_expansion_allowed",
         FT_BOOLEAN, 8, NULL, 0,
-        "DLPolicy/further-dl-expansion-allowed", HFILL }},
+        "acp133.BOOLEAN", HFILL }},
     { &hf_acp133_originator_requested_alternate_recipient_removed,
       { "originator-requested-alternate-recipient-removed", "acp133.originator_requested_alternate_recipient_removed",
         FT_BOOLEAN, 8, NULL, 0,
-        "DLPolicy/originator-requested-alternate-recipient-removed", HFILL }},
+        "acp133.BOOLEAN", HFILL }},
     { &hf_acp133_proof_of_delivery,
       { "proof-of-delivery", "acp133.proof_of_delivery",
         FT_INT32, BASE_DEC, VALS(acp133_T_proof_of_delivery_vals), 0,
-        "DLPolicy/proof-of-delivery", HFILL }},
+        "acp133.T_proof_of_delivery", HFILL }},
     { &hf_acp133_requested_delivery_method,
       { "requested-delivery-method", "acp133.requested_delivery_method",
         FT_UINT32, BASE_DEC, VALS(acp133_T_requested_delivery_method_vals), 0,
-        "DLPolicy/requested-delivery-method", HFILL }},
+        "acp133.T_requested_delivery_method", HFILL }},
     { &hf_acp133_unchanged,
       { "unchanged", "acp133.unchanged",
         FT_NONE, BASE_NONE, NULL, 0,
-        "DLPolicy/requested-delivery-method/unchanged", HFILL }},
+        "acp133.NULL", HFILL }},
     { &hf_acp133_removed,
       { "removed", "acp133.removed",
         FT_NONE, BASE_NONE, NULL, 0,
-        "DLPolicy/requested-delivery-method/removed", HFILL }},
+        "acp133.NULL", HFILL }},
     { &hf_acp133_replaced,
       { "replaced", "acp133.replaced",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "DLPolicy/requested-delivery-method/replaced", HFILL }},
+        "x411.RequestedDeliveryMethod", HFILL }},
     { &hf_acp133_token_encryption_algorithm_preference,
       { "token-encryption-algorithm-preference", "acp133.token_encryption_algorithm_preference",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "DLPolicy/token-encryption-algorithm-preference", HFILL }},
+        "acp133.SEQUENCE_OF_AlgorithmInformation", HFILL }},
     { &hf_acp133_token_encryption_algorithm_preference_item,
       { "Item", "acp133.token_encryption_algorithm_preference_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "DLPolicy/token-encryption-algorithm-preference/_item", HFILL }},
+        "acp133.AlgorithmInformation", HFILL }},
     { &hf_acp133_token_signature_algorithm_preference,
       { "token-signature-algorithm-preference", "acp133.token_signature_algorithm_preference",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "DLPolicy/token-signature-algorithm-preference", HFILL }},
+        "acp133.SEQUENCE_OF_AlgorithmInformation", HFILL }},
     { &hf_acp133_token_signature_algorithm_preference_item,
       { "Item", "acp133.token_signature_algorithm_preference_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "DLPolicy/token-signature-algorithm-preference/_item", HFILL }},
+        "acp133.AlgorithmInformation", HFILL }},
     { &hf_acp133_originator_certificate_selector,
       { "originator-certificate-selector", "acp133.originator_certificate_selector",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AlgorithmInformation/originator-certificate-selector", HFILL }},
+        "x509ce.CertificateAssertion", HFILL }},
     { &hf_acp133_recipient_certificate_selector,
       { "recipient-certificate-selector", "acp133.recipient_certificate_selector",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AlgorithmInformation/recipient-certificate-selector", HFILL }},
+        "x509ce.CertificateAssertion", HFILL }},
     { &hf_acp133_description,
       { "description", "acp133.description",
         FT_STRING, BASE_NONE, NULL, 0,
-        "AddressCapabilities/description", HFILL }},
+        "acp133.GeneralString", HFILL }},
     { &hf_acp133_address,
       { "address", "acp133.address",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AddressCapabilities/address", HFILL }},
+        "x411.ORAddress", HFILL }},
     { &hf_acp133_capabilities,
       { "capabilities", "acp133.capabilities",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "AddressCapabilities/capabilities", HFILL }},
+        "acp133.SET_OF_Capability", HFILL }},
     { &hf_acp133_capabilities_item,
       { "Item", "acp133.capabilities_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AddressCapabilities/capabilities/_item", HFILL }},
+        "acp133.Capability", HFILL }},
     { &hf_acp133_content_types,
       { "content-types", "acp133.content_types",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Capability/content-types", HFILL }},
+        "acp133.SET_OF_ExtendedContentType", HFILL }},
     { &hf_acp133_content_types_item,
       { "Item", "acp133.content_types_item",
         FT_OID, BASE_NONE, NULL, 0,
-        "Capability/content-types/_item", HFILL }},
+        "x411.ExtendedContentType", HFILL }},
     { &hf_acp133_maximum_content_length,
       { "maximum-content-length", "acp133.maximum_content_length",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Capability/maximum-content-length", HFILL }},
+        "x411.ContentLength", HFILL }},
     { &hf_acp133_encoded_information_types_constraints,
       { "encoded-information-types-constraints", "acp133.encoded_information_types_constraints",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Capability/encoded-information-types-constraints", HFILL }},
+        "x411.EncodedInformationTypesConstraints", HFILL }},
     { &hf_acp133_security_labels,
       { "security-labels", "acp133.security_labels",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Capability/security-labels", HFILL }},
+        "x411.SecurityContext", HFILL }},
     { &hf_acp133_OnSupported_acp127_nn,
       { "acp127-nn", "acp133.acp127-nn",
         FT_BOOLEAN, 8, NULL, 0x80,
index c3b696ccacc7b63b7e0d1053a9ff6b8bcc907c70..a626bcc24aa4f506f0d2bc74099a5300700eba90 100644 (file)
@@ -1986,399 +1986,399 @@ void proto_register_acse(void) {
     { &hf_acse_direct_reference,
       { "direct-reference", "acse.direct_reference",
         FT_OID, BASE_NONE, NULL, 0,
-        "EXTERNAL/direct-reference", HFILL }},
+        "acse.T_direct_reference", HFILL }},
     { &hf_acse_indirect_reference,
       { "indirect-reference", "acse.indirect_reference",
         FT_INT32, BASE_DEC, NULL, 0,
-        "EXTERNAL/indirect-reference", HFILL }},
+        "acse.T_indirect_reference", HFILL }},
     { &hf_acse_data_value_descriptor,
       { "data-value-descriptor", "acse.data_value_descriptor",
         FT_STRING, BASE_NONE, NULL, 0,
-        "EXTERNAL/data-value-descriptor", HFILL }},
+        "acse.ObjectDescriptor", HFILL }},
     { &hf_acse_encoding,
       { "encoding", "acse.encoding",
         FT_UINT32, BASE_DEC, VALS(acse_T_encoding_vals), 0,
-        "EXTERNAL/encoding", HFILL }},
+        "acse.T_encoding", HFILL }},
     { &hf_acse_single_ASN1_type,
       { "single-ASN1-type", "acse.single_ASN1_type",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EXTERNAL/encoding/single-ASN1-type", HFILL }},
+        "acse.T_single_ASN1_type", HFILL }},
     { &hf_acse_octet_aligned,
       { "octet-aligned", "acse.octet_aligned",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "acse.OCTET_STRING", HFILL }},
     { &hf_acse_arbitrary,
       { "arbitrary", "acse.arbitrary",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "acse.BIT_STRING", HFILL }},
     { &hf_acse_aarq,
       { "aarq", "acse.aarq",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ACSE-apdu/aarq", HFILL }},
+        "acse.AARQ_apdu", HFILL }},
     { &hf_acse_aare,
       { "aare", "acse.aare",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ACSE-apdu/aare", HFILL }},
+        "acse.AARE_apdu", HFILL }},
     { &hf_acse_rlrq,
       { "rlrq", "acse.rlrq",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ACSE-apdu/rlrq", HFILL }},
+        "acse.RLRQ_apdu", HFILL }},
     { &hf_acse_rlre,
       { "rlre", "acse.rlre",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ACSE-apdu/rlre", HFILL }},
+        "acse.RLRE_apdu", HFILL }},
     { &hf_acse_abrt,
       { "abrt", "acse.abrt",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ACSE-apdu/abrt", HFILL }},
+        "acse.ABRT_apdu", HFILL }},
     { &hf_acse_adt,
       { "adt", "acse.adt",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ACSE-apdu/adt", HFILL }},
+        "acse.A_DT_apdu", HFILL }},
     { &hf_acse_acrq,
       { "acrq", "acse.acrq",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ACSE-apdu/acrq", HFILL }},
+        "acse.ACRQ_apdu", HFILL }},
     { &hf_acse_acrp,
       { "acrp", "acse.acrp",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ACSE-apdu/acrp", HFILL }},
+        "acse.ACRP_apdu", HFILL }},
     { &hf_acse_aARQ_protocol_version,
       { "protocol-version", "acse.protocol_version",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "AARQ-apdu/protocol-version", HFILL }},
+        "acse.T_AARQ_protocol_version", HFILL }},
     { &hf_acse_aARQ_aSO_context_name,
       { "aSO-context-name", "acse.aSO_context_name",
         FT_OID, BASE_NONE, NULL, 0,
-        "AARQ-apdu/aSO-context-name", HFILL }},
+        "acse.T_AARQ_aSO_context_name", HFILL }},
     { &hf_acse_called_AP_title,
       { "called-AP-title", "acse.called_AP_title",
         FT_UINT32, BASE_DEC, VALS(acse_AP_title_vals), 0,
-        "AARQ-apdu/called-AP-title", HFILL }},
+        "acse.AP_title", HFILL }},
     { &hf_acse_called_AE_qualifier,
       { "called-AE-qualifier", "acse.called_AE_qualifier",
         FT_UINT32, BASE_DEC, VALS(acse_ASO_qualifier_vals), 0,
-        "AARQ-apdu/called-AE-qualifier", HFILL }},
+        "acse.AE_qualifier", HFILL }},
     { &hf_acse_called_AP_invocation_identifier,
       { "called-AP-invocation-identifier", "acse.called_AP_invocation_identifier",
         FT_INT32, BASE_DEC, NULL, 0,
-        "AARQ-apdu/called-AP-invocation-identifier", HFILL }},
+        "acse.AP_invocation_identifier", HFILL }},
     { &hf_acse_called_AE_invocation_identifier,
       { "called-AE-invocation-identifier", "acse.called_AE_invocation_identifier",
         FT_INT32, BASE_DEC, NULL, 0,
-        "AARQ-apdu/called-AE-invocation-identifier", HFILL }},
+        "acse.AE_invocation_identifier", HFILL }},
     { &hf_acse_calling_AP_title,
       { "calling-AP-title", "acse.calling_AP_title",
         FT_UINT32, BASE_DEC, VALS(acse_AP_title_vals), 0,
-        "AARQ-apdu/calling-AP-title", HFILL }},
+        "acse.AP_title", HFILL }},
     { &hf_acse_calling_AE_qualifier,
       { "calling-AE-qualifier", "acse.calling_AE_qualifier",
         FT_UINT32, BASE_DEC, VALS(acse_ASO_qualifier_vals), 0,
-        "AARQ-apdu/calling-AE-qualifier", HFILL }},
+        "acse.AE_qualifier", HFILL }},
     { &hf_acse_calling_AP_invocation_identifier,
       { "calling-AP-invocation-identifier", "acse.calling_AP_invocation_identifier",
         FT_INT32, BASE_DEC, NULL, 0,
-        "AARQ-apdu/calling-AP-invocation-identifier", HFILL }},
+        "acse.AP_invocation_identifier", HFILL }},
     { &hf_acse_calling_AE_invocation_identifier,
       { "calling-AE-invocation-identifier", "acse.calling_AE_invocation_identifier",
         FT_INT32, BASE_DEC, NULL, 0,
-        "AARQ-apdu/calling-AE-invocation-identifier", HFILL }},
+        "acse.AE_invocation_identifier", HFILL }},
     { &hf_acse_sender_acse_requirements,
       { "sender-acse-requirements", "acse.sender_acse_requirements",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "AARQ-apdu/sender-acse-requirements", HFILL }},
+        "acse.ACSE_requirements", HFILL }},
     { &hf_acse_mechanism_name,
       { "mechanism-name", "acse.mechanism_name",
         FT_OID, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "acse.Mechanism_name", HFILL }},
     { &hf_acse_calling_authentication_value,
       { "calling-authentication-value", "acse.calling_authentication_value",
         FT_UINT32, BASE_DEC, VALS(acse_Authentication_value_vals), 0,
-        "AARQ-apdu/calling-authentication-value", HFILL }},
+        "acse.Authentication_value", HFILL }},
     { &hf_acse_aSO_context_name_list,
       { "aSO-context-name-list", "acse.aSO_context_name_list",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "acse.ASO_context_name_list", HFILL }},
     { &hf_acse_implementation_information,
       { "implementation-information", "acse.implementation_information",
         FT_STRING, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "acse.Implementation_data", HFILL }},
     { &hf_acse_p_context_definition_list,
       { "p-context-definition-list", "acse.p_context_definition_list",
         FT_UINT32, BASE_DEC, VALS(acse_Syntactic_context_list_vals), 0,
-        "", HFILL }},
+        "acse.Syntactic_context_list", HFILL }},
     { &hf_acse_called_asoi_tag,
       { "called-asoi-tag", "acse.called_asoi_tag",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "acse.ASOI_tag", HFILL }},
     { &hf_acse_calling_asoi_tag,
       { "calling-asoi-tag", "acse.calling_asoi_tag",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "acse.ASOI_tag", HFILL }},
     { &hf_acse_aARQ_user_information,
       { "user-information", "acse.user_information",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "AARQ-apdu/user-information", HFILL }},
+        "acse.Association_data", HFILL }},
     { &hf_acse_aARE_protocol_version,
       { "protocol-version", "acse.protocol_version",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "AARE-apdu/protocol-version", HFILL }},
+        "acse.T_AARE_protocol_version", HFILL }},
     { &hf_acse_aARE_aSO_context_name,
       { "aSO-context-name", "acse.aSO_context_name",
         FT_OID, BASE_NONE, NULL, 0,
-        "AARE-apdu/aSO-context-name", HFILL }},
+        "acse.T_AARE_aSO_context_name", HFILL }},
     { &hf_acse_aARE_result,
       { "result", "acse.result",
         FT_UINT32, BASE_DEC, VALS(acse_Associate_result_vals), 0,
-        "AARE-apdu/result", HFILL }},
+        "acse.Associate_result", HFILL }},
     { &hf_acse_result_source_diagnostic,
       { "result-source-diagnostic", "acse.result_source_diagnostic",
         FT_UINT32, BASE_DEC, VALS(acse_Associate_source_diagnostic_vals), 0,
-        "AARE-apdu/result-source-diagnostic", HFILL }},
+        "acse.Associate_source_diagnostic", HFILL }},
     { &hf_acse_responding_AP_title,
       { "responding-AP-title", "acse.responding_AP_title",
         FT_UINT32, BASE_DEC, VALS(acse_AP_title_vals), 0,
-        "AARE-apdu/responding-AP-title", HFILL }},
+        "acse.AP_title", HFILL }},
     { &hf_acse_responding_AE_qualifier,
       { "responding-AE-qualifier", "acse.responding_AE_qualifier",
         FT_UINT32, BASE_DEC, VALS(acse_ASO_qualifier_vals), 0,
-        "AARE-apdu/responding-AE-qualifier", HFILL }},
+        "acse.AE_qualifier", HFILL }},
     { &hf_acse_responding_AP_invocation_identifier,
       { "responding-AP-invocation-identifier", "acse.responding_AP_invocation_identifier",
         FT_INT32, BASE_DEC, NULL, 0,
-        "AARE-apdu/responding-AP-invocation-identifier", HFILL }},
+        "acse.AP_invocation_identifier", HFILL }},
     { &hf_acse_responding_AE_invocation_identifier,
       { "responding-AE-invocation-identifier", "acse.responding_AE_invocation_identifier",
         FT_INT32, BASE_DEC, NULL, 0,
-        "AARE-apdu/responding-AE-invocation-identifier", HFILL }},
+        "acse.AE_invocation_identifier", HFILL }},
     { &hf_acse_responder_acse_requirements,
       { "responder-acse-requirements", "acse.responder_acse_requirements",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "AARE-apdu/responder-acse-requirements", HFILL }},
+        "acse.ACSE_requirements", HFILL }},
     { &hf_acse_responding_authentication_value,
       { "responding-authentication-value", "acse.responding_authentication_value",
         FT_UINT32, BASE_DEC, VALS(acse_Authentication_value_vals), 0,
-        "AARE-apdu/responding-authentication-value", HFILL }},
+        "acse.Authentication_value", HFILL }},
     { &hf_acse_p_context_result_list,
       { "p-context-result-list", "acse.p_context_result_list",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "acse.P_context_result_list", HFILL }},
     { &hf_acse_aARE_user_information,
       { "user-information", "acse.user_information",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "AARE-apdu/user-information", HFILL }},
+        "acse.Association_data", HFILL }},
     { &hf_acse_rLRQ_reason,
       { "reason", "acse.reason",
         FT_INT32, BASE_DEC, VALS(acse_Release_request_reason_vals), 0,
-        "RLRQ-apdu/reason", HFILL }},
+        "acse.Release_request_reason", HFILL }},
     { &hf_acse_aso_qualifier,
       { "aso-qualifier", "acse.aso_qualifier",
         FT_UINT32, BASE_DEC, VALS(acse_ASO_qualifier_vals), 0,
-        "", HFILL }},
+        "acse.ASO_qualifier", HFILL }},
     { &hf_acse_asoi_identifier,
       { "asoi-identifier", "acse.asoi_identifier",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "acse.ASOI_identifier", HFILL }},
     { &hf_acse_rLRQ_user_information,
       { "user-information", "acse.user_information",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "RLRQ-apdu/user-information", HFILL }},
+        "acse.Association_data", HFILL }},
     { &hf_acse_rLRE_reason,
       { "reason", "acse.reason",
         FT_INT32, BASE_DEC, VALS(acse_Release_response_reason_vals), 0,
-        "RLRE-apdu/reason", HFILL }},
+        "acse.Release_response_reason", HFILL }},
     { &hf_acse_rLRE_user_information,
       { "user-information", "acse.user_information",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "RLRE-apdu/user-information", HFILL }},
+        "acse.Association_data", HFILL }},
     { &hf_acse_abort_source,
       { "abort-source", "acse.abort_source",
         FT_UINT32, BASE_DEC, VALS(acse_ABRT_source_vals), 0,
-        "ABRT-apdu/abort-source", HFILL }},
+        "acse.ABRT_source", HFILL }},
     { &hf_acse_abort_diagnostic,
       { "abort-diagnostic", "acse.abort_diagnostic",
         FT_UINT32, BASE_DEC, VALS(acse_ABRT_diagnostic_vals), 0,
-        "ABRT-apdu/abort-diagnostic", HFILL }},
+        "acse.ABRT_diagnostic", HFILL }},
     { &hf_acse_aBRT_user_information,
       { "user-information", "acse.user_information",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ABRT-apdu/user-information", HFILL }},
+        "acse.Association_data", HFILL }},
     { &hf_acse_a_user_data,
       { "a-user-data", "acse.a_user_data",
         FT_UINT32, BASE_DEC, VALS(acse_User_Data_vals), 0,
-        "A-DT-apdu/a-user-data", HFILL }},
+        "acse.User_Data", HFILL }},
     { &hf_acse_aCRQ_aSO_context_name,
       { "aSO-context-name", "acse.aSO_context_name",
         FT_OID, BASE_NONE, NULL, 0,
-        "ACRQ-apdu/aSO-context-name", HFILL }},
+        "acse.T_ACRQ_aSO_context_name", HFILL }},
     { &hf_acse_user_information,
       { "user-information", "acse.user_information",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "acse.User_information", HFILL }},
     { &hf_acse_aSO_context_name,
       { "aSO-context-name", "acse.aSO_context_name",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ACRP-apdu/aSO-context-name", HFILL }},
+        "acse.T_ACRP_aSO_context_name", HFILL }},
     { &hf_acse_ap_title_form1,
       { "ap-title-form1", "acse.ap_title_form1",
         FT_UINT32, BASE_DEC, VALS(x509if_Name_vals), 0,
-        "AP-title/ap-title-form1", HFILL }},
+        "acse.AP_title_form1", HFILL }},
     { &hf_acse_ap_title_form2,
       { "ap-title-form2", "acse.ap_title_form2",
         FT_OID, BASE_NONE, NULL, 0,
-        "AP-title/ap-title-form2", HFILL }},
+        "acse.AP_title_form2", HFILL }},
     { &hf_acse_ap_title_form3,
       { "ap-title-form3", "acse.ap_title_form3",
         FT_STRING, BASE_NONE, NULL, 0,
-        "AP-title/ap-title-form3", HFILL }},
+        "acse.AP_title_form3", HFILL }},
     { &hf_acse_aso_qualifier_form1,
       { "aso-qualifier-form1", "acse.aso_qualifier_form1",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ASO-qualifier/aso-qualifier-form1", HFILL }},
+        "acse.ASO_qualifier_form1", HFILL }},
     { &hf_acse_aso_qualifier_form2,
       { "aso-qualifier-form2", "acse.aso_qualifier_form2",
         FT_INT32, BASE_DEC, NULL, 0,
-        "ASO-qualifier/aso-qualifier-form2", HFILL }},
+        "acse.ASO_qualifier_form2", HFILL }},
     { &hf_acse_aso_qualifier_form3,
       { "aso-qualifier-form3", "acse.aso_qualifier_form3",
         FT_STRING, BASE_NONE, NULL, 0,
-        "ASO-qualifier/aso-qualifier-form3", HFILL }},
+        "acse.ASO_qualifier_form3", HFILL }},
     { &hf_acse_ae_title_form1,
       { "ae-title-form1", "acse.ae_title_form1",
         FT_UINT32, BASE_DEC, VALS(x509if_Name_vals), 0,
-        "AE-title/ae-title-form1", HFILL }},
+        "acse.AE_title_form1", HFILL }},
     { &hf_acse_ae_title_form2,
       { "ae-title-form2", "acse.ae_title_form2",
         FT_OID, BASE_NONE, NULL, 0,
-        "AE-title/ae-title-form2", HFILL }},
+        "acse.AE_title_form2", HFILL }},
     { &hf_acse_ASOI_tag_item,
       { "Item", "acse.ASOI_tag_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ASOI-tag/_item", HFILL }},
+        "acse.ASOI_tag_item", HFILL }},
     { &hf_acse_qualifier,
       { "qualifier", "acse.qualifier",
         FT_UINT32, BASE_DEC, VALS(acse_ASO_qualifier_vals), 0,
-        "ASOI-tag/_item/qualifier", HFILL }},
+        "acse.ASO_qualifier", HFILL }},
     { &hf_acse_identifier,
       { "identifier", "acse.identifier",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ASOI-tag/_item/identifier", HFILL }},
+        "acse.ASOI_identifier", HFILL }},
     { &hf_acse_ASO_context_name_list_item,
       { "Item", "acse.ASO_context_name_list_item",
         FT_OID, BASE_NONE, NULL, 0,
-        "ASO-context-name-list/_item", HFILL }},
+        "acse.ASO_context_name", HFILL }},
     { &hf_acse_context_list,
       { "context-list", "acse.context_list",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Syntactic-context-list/context-list", HFILL }},
+        "acse.Context_list", HFILL }},
     { &hf_acse_default_contact_list,
       { "default-contact-list", "acse.default_contact_list",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Syntactic-context-list/default-contact-list", HFILL }},
+        "acse.Default_Context_List", HFILL }},
     { &hf_acse_Context_list_item,
       { "Item", "acse.Context_list_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Context-list/_item", HFILL }},
+        "acse.Context_list_item", HFILL }},
     { &hf_acse_pci,
       { "pci", "acse.pci",
         FT_INT32, BASE_DEC, NULL, 0,
-        "Context-list/_item/pci", HFILL }},
+        "acse.Presentation_context_identifier", HFILL }},
     { &hf_acse_abstract_syntax,
       { "abstract-syntax", "acse.abstract_syntax",
         FT_OID, BASE_NONE, NULL, 0,
-        "Context-list/_item/abstract-syntax", HFILL }},
+        "acse.Abstract_syntax_name", HFILL }},
     { &hf_acse_transfer_syntaxes,
       { "transfer-syntaxes", "acse.transfer_syntaxes",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Context-list/_item/transfer-syntaxes", HFILL }},
+        "acse.SEQUENCE_OF_TransferSyntaxName", HFILL }},
     { &hf_acse_transfer_syntaxes_item,
       { "Item", "acse.transfer_syntaxes_item",
         FT_OID, BASE_NONE, NULL, 0,
-        "Context-list/_item/transfer-syntaxes/_item", HFILL }},
+        "acse.TransferSyntaxName", HFILL }},
     { &hf_acse_Default_Context_List_item,
       { "Item", "acse.Default_Context_List_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Default-Context-List/_item", HFILL }},
+        "acse.Default_Context_List_item", HFILL }},
     { &hf_acse_abstract_syntax_name,
       { "abstract-syntax-name", "acse.abstract_syntax_name",
         FT_OID, BASE_NONE, NULL, 0,
-        "Default-Context-List/_item/abstract-syntax-name", HFILL }},
+        "acse.Abstract_syntax_name", HFILL }},
     { &hf_acse_transfer_syntax_name,
       { "transfer-syntax-name", "acse.transfer_syntax_name",
         FT_OID, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "acse.TransferSyntaxName", HFILL }},
     { &hf_acse_P_context_result_list_item,
       { "Item", "acse.P_context_result_list_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "P-context-result-list/_item", HFILL }},
+        "acse.P_context_result_list_item", HFILL }},
     { &hf_acse_pcontext_result,
       { "result", "acse.result",
         FT_INT32, BASE_DEC, VALS(acse_Result_vals), 0,
-        "P-context-result-list/_item/result", HFILL }},
+        "acse.Result", HFILL }},
     { &hf_acse_concrete_syntax_name,
       { "concrete-syntax-name", "acse.concrete_syntax_name",
         FT_OID, BASE_NONE, NULL, 0,
-        "P-context-result-list/_item/concrete-syntax-name", HFILL }},
+        "acse.Concrete_syntax_name", HFILL }},
     { &hf_acse_provider_reason,
       { "provider-reason", "acse.provider_reason",
         FT_INT32, BASE_DEC, VALS(acse_T_provider_reason_vals), 0,
-        "P-context-result-list/_item/provider-reason", HFILL }},
+        "acse.T_provider_reason", HFILL }},
     { &hf_acse_acse_service_user,
       { "acse-service-user", "acse.acse_service_user",
         FT_UINT32, BASE_DEC, VALS(acse_T_acse_service_user_vals), 0,
-        "Associate-source-diagnostic/acse-service-user", HFILL }},
+        "acse.T_acse_service_user", HFILL }},
     { &hf_acse_acse_service_provider,
       { "acse-service-provider", "acse.acse_service_provider",
         FT_UINT32, BASE_DEC, VALS(acse_T_acse_service_provider_vals), 0,
-        "Associate-source-diagnostic/acse-service-provider", HFILL }},
+        "acse.T_acse_service_provider", HFILL }},
     { &hf_acse_Association_data_item,
       { "Item", "acse.Association_data_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Association-data/_item", HFILL }},
+        "acse.EXTERNAL", HFILL }},
     { &hf_acse_simply_encoded_data,
       { "simply-encoded-data", "acse.simply_encoded_data",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "User-Data/simply-encoded-data", HFILL }},
+        "acse.Simply_encoded_data", HFILL }},
     { &hf_acse_fully_encoded_data,
       { "fully-encoded-data", "acse.fully_encoded_data",
         FT_NONE, BASE_NONE, NULL, 0,
-        "User-Data/fully-encoded-data", HFILL }},
+        "acse.PDV_list", HFILL }},
     { &hf_acse_presentation_context_identifier,
       { "presentation-context-identifier", "acse.presentation_context_identifier",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PDV-list/presentation-context-identifier", HFILL }},
+        "acse.Presentation_context_identifier", HFILL }},
     { &hf_acse_presentation_data_values,
       { "presentation-data-values", "acse.presentation_data_values",
         FT_UINT32, BASE_DEC, VALS(acse_T_presentation_data_values_vals), 0,
-        "PDV-list/presentation-data-values", HFILL }},
+        "acse.T_presentation_data_values", HFILL }},
     { &hf_acse_simple_ASN1_type,
       { "simple-ASN1-type", "acse.simple_ASN1_type",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PDV-list/presentation-data-values/simple-ASN1-type", HFILL }},
+        "acse.T_simple_ASN1_type", HFILL }},
     { &hf_acse_other_mechanism_name,
       { "other-mechanism-name", "acse.other_mechanism_name",
         FT_OID, BASE_NONE, NULL, 0,
-        "Authentication-value-other/other-mechanism-name", HFILL }},
+        "acse.T_other_mechanism_name", HFILL }},
     { &hf_acse_other_mechanism_value,
       { "other-mechanism-value", "acse.other_mechanism_value",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Authentication-value-other/other-mechanism-value", HFILL }},
+        "acse.T_other_mechanism_value", HFILL }},
     { &hf_acse_charstring,
       { "charstring", "acse.charstring",
         FT_STRING, BASE_NONE, NULL, 0,
-        "Authentication-value/charstring", HFILL }},
+        "acse.GraphicString", HFILL }},
     { &hf_acse_bitstring,
       { "bitstring", "acse.bitstring",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "Authentication-value/bitstring", HFILL }},
+        "acse.BIT_STRING", HFILL }},
     { &hf_acse_external,
       { "external", "acse.external",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Authentication-value/external", HFILL }},
+        "acse.EXTERNAL", HFILL }},
     { &hf_acse_other,
       { "other", "acse.other",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Authentication-value/other", HFILL }},
+        "acse.Authentication_value_other", HFILL }},
     { &hf_acse_T_AARQ_protocol_version_version1,
       { "version1", "acse.version1",
         FT_BOOLEAN, 8, NULL, 0x80,
index d3708eb5bb500779b9e01066df4bc8025a50d5ca..202036573dd8864b11e7b4b5b4badc2127bc5f2f 100644 (file)
@@ -8523,1831 +8523,1831 @@ void proto_register_camel(void) {
     { &hf_camel_reserved,
       { "reserved", "camel.reserved",
         FT_INT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_aoc,
       { "aoc", "camel.aoc",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PBSGSNCapabilities/aoc", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_standardPartEnd,
       { "standardPartEnd", "camel.standardPartEnd",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PBIPSSPCapabilities/standardPartEnd", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_genOfVoiceAnn,
       { "genOfVoiceAnn", "camel.genOfVoiceAnn",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PBIPSSPCapabilities/genOfVoiceAnn", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_voiceInfo2,
       { "voiceInfo2", "camel.voiceInfo2",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PBIPSSPCapabilities/voiceInfo2", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_voiceInfo1,
       { "voiceInfo1", "camel.voiceInfo1",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PBIPSSPCapabilities/voiceInfo1", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_voiceBack1,
       { "voiceBack1", "camel.voiceBack1",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PBIPSSPCapabilities/voiceBack1", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_iPRoutAdd,
       { "iPRoutAdd", "camel.iPRoutAdd",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PBIPSSPCapabilities/iPRoutAdd", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_bilateralPart,
       { "bilateralPart", "camel.bilateralPart",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PBIPSSPCapabilities/bilateralPart", HFILL }},
+        "camel.OCTET_STRING_SIZE_0_3", HFILL }},
     { &hf_camel_extension,
       { "extension", "camel.extension",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "camel.INTEGER_1", HFILL }},
     { &hf_camel_natureOfAddressIndicator,
       { "natureOfAddressIndicator", "camel.natureOfAddressIndicator",
         FT_INT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_numberingPlanInd,
       { "numberingPlanInd", "camel.numberingPlanInd",
         FT_INT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_digits1,
       { "digits1", "camel.digits1",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PBAddressString/digits1", HFILL }},
+        "camel.OCTET_STRING_SIZE_0_19", HFILL }},
     { &hf_camel_digits2,
       { "digits2", "camel.digits2",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PBISDNAddressString/digits2", HFILL }},
+        "camel.OCTET_STRING_SIZE_0_8", HFILL }},
     { &hf_camel_typeOfShape,
       { "typeOfShape", "camel.typeOfShape",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PBGeographicalInformation/typeOfShape", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_spare3,
       { "spare3", "camel.spare3",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PBGeographicalInformation/spare3", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_degreesOfLatitude,
       { "degreesOfLatitude", "camel.degreesOfLatitude",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PBGeographicalInformation/degreesOfLatitude", HFILL }},
+        "camel.OCTET_STRING_SIZE_3", HFILL }},
     { &hf_camel_degreesOfLongitude,
       { "degreesOfLongitude", "camel.degreesOfLongitude",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PBGeographicalInformation/degreesOfLongitude", HFILL }},
+        "camel.OCTET_STRING_SIZE_3", HFILL }},
     { &hf_camel_uncertaintyCode,
       { "uncertaintyCode", "camel.uncertaintyCode",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PBGeographicalInformation/uncertaintyCode", HFILL }},
+        "camel.OCTET_STRING_SIZE_1", HFILL }},
     { &hf_camel_typeOfAddress,
       { "typeOfAddress", "camel.typeOfAddress",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PBGSNAddress/typeOfAddress", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_addressLength,
       { "addressLength", "camel.addressLength",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PBGSNAddress/addressLength", HFILL }},
+        "camel.INTEGER_4_16", HFILL }},
     { &hf_camel_address,
       { "address", "camel.address",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PBGSNAddress/address", HFILL }},
+        "camel.OCTET_STRING_SIZE_4_16", HFILL }},
     { &hf_camel_originalReasons,
       { "originalReasons", "camel.originalReasons",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PBRedirectionInformation/originalReasons", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_spare4,
       { "spare4", "camel.spare4",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PBRedirectionInformation/spare4", HFILL }},
+        "camel.INTEGER_0", HFILL }},
     { &hf_camel_indicator,
       { "indicator", "camel.indicator",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PBRedirectionInformation/indicator", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_reason,
       { "reason", "camel.reason",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PBRedirectionInformation/reason", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_spare2,
       { "spare2", "camel.spare2",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PBRedirectionInformation/spare2", HFILL }},
+        "camel.INTEGER_0", HFILL }},
     { &hf_camel_counter,
       { "counter", "camel.counter",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PBRedirectionInformation/counter", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_oddEven,
       { "oddEven", "camel.oddEven",
         FT_INT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_innInd,
       { "innInd", "camel.innInd",
         FT_INT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_spare5,
       { "spare5", "camel.spare5",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PBCalledPartyNumber/spare5", HFILL }},
+        "camel.INTEGER_0", HFILL }},
     { &hf_camel_digits3,
       { "digits3", "camel.digits3",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PBCalledPartyNumber/digits3", HFILL }},
+        "camel.OCTET_STRING_SIZE_0_16", HFILL }},
     { &hf_camel_niInd,
       { "niInd", "camel.niInd",
         FT_INT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_presentInd,
       { "presentInd", "camel.presentInd",
         FT_INT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_screening,
       { "screening", "camel.screening",
         FT_INT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_digits4,
       { "digits4", "camel.digits4",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PBCallingPartyNumber/digits4", HFILL }},
+        "camel.OCTET_STRING_SIZE_0_8", HFILL }},
     { &hf_camel_spare6,
       { "spare6", "camel.spare6",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PBRedirectingNumber/spare6", HFILL }},
+        "camel.INTEGER_0", HFILL }},
     { &hf_camel_digits5,
       { "digits5", "camel.digits5",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PBRedirectingNumber/digits5", HFILL }},
+        "camel.OCTET_STRING_SIZE_1_10", HFILL }},
     { &hf_camel_o1ext,
       { "o1ext", "camel.o1ext",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PBCause/o1ext", HFILL }},
+        "camel.INTEGER_1", HFILL }},
     { &hf_camel_codingStandard,
       { "codingStandard", "camel.codingStandard",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PBCause/codingStandard", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_spare77,
       { "spare77", "camel.spare77",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PBCause/spare77", HFILL }},
+        "camel.INTEGER_0", HFILL }},
     { &hf_camel_location,
       { "location", "camel.location",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PBCause/location", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_o2ext,
       { "o2ext", "camel.o2ext",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PBCause/o2ext", HFILL }},
+        "camel.INTEGER_1", HFILL }},
     { &hf_camel_causeValue,
       { "causeValue", "camel.causeValue",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PBCause/causeValue", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_diagnostics,
       { "diagnostics", "camel.diagnostics",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PBCause/diagnostics", HFILL }},
+        "camel.OCTET_STRING_SIZE_0_30", HFILL }},
     { &hf_camel_numberQualifierIndicator,
       { "numberQualifierIndicator", "camel.numberQualifierIndicator",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PBGenericNumber/numberQualifierIndicator", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_digits6,
       { "digits6", "camel.digits6",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PBGenericNumber/digits6", HFILL }},
+        "camel.OCTET_STRING_SIZE_0_8", HFILL }},
     { &hf_camel_digits7,
       { "digits7", "camel.digits7",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PBLocationNumber/digits7", HFILL }},
+        "camel.OCTET_STRING_SIZE_0_8", HFILL }},
     { &hf_camel_ext,
       { "ext", "camel.ext",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PBCalledPartyBCDNumber/ext", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_typeOfNumber,
       { "typeOfNumber", "camel.typeOfNumber",
         FT_UINT32, BASE_DEC, VALS(camel_T_typeOfNumber_vals), 0,
-        "PBCalledPartyBCDNumber/typeOfNumber", HFILL }},
+        "camel.T_typeOfNumber", HFILL }},
     { &hf_camel_digits8,
       { "digits8", "camel.digits8",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PBCalledPartyBCDNumber/digits8", HFILL }},
+        "camel.OCTET_STRING_SIZE_0_40", HFILL }},
     { &hf_camel_actimeDurationCharging,
       { "actimeDurationCharging", "camel.actimeDurationCharging",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AChBillingChargingCharacteristics/actimeDurationCharging", HFILL }},
+        "camel.T_actimeDurationCharging", HFILL }},
     { &hf_camel_maxCallPeriodDuration,
       { "maxCallPeriodDuration", "camel.maxCallPeriodDuration",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "camel.INTEGER_1_864000", HFILL }},
     { &hf_camel_releaseIfdurationExceeded,
       { "releaseIfdurationExceeded", "camel.releaseIfdurationExceeded",
         FT_BOOLEAN, 8, NULL, 0,
-        "", HFILL }},
+        "camel.BOOLEAN", HFILL }},
     { &hf_camel_tariffSwitchInterval,
       { "tariffSwitchInterval", "camel.tariffSwitchInterval",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "camel.INTEGER_1_86400", HFILL }},
     { &hf_camel_actone,
       { "actone", "camel.actone",
         FT_BOOLEAN, 8, NULL, 0,
-        "AChBillingChargingCharacteristics/actimeDurationCharging/actone", HFILL }},
+        "camel.BOOLEAN", HFILL }},
     { &hf_camel_extensions,
       { "extensions", "camel.extensions",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "camel.ExtensionsArray", HFILL }},
     { &hf_camel_legID,
       { "legID", "camel.legID",
         FT_UINT32, BASE_DEC, VALS(camel_LegID_vals), 0,
-        "", HFILL }},
+        "camel.LegID", HFILL }},
     { &hf_camel_srfConnection,
       { "srfConnection", "camel.srfConnection",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "AChChargingAddress/srfConnection", HFILL }},
+        "camel.CallSegmentID", HFILL }},
     { &hf_camel_aOCInitial,
       { "aOCInitial", "camel.aOCInitial",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "camel.CAI_Gsm0224", HFILL }},
     { &hf_camel_aOCSubsequent,
       { "aOCSubsequent", "camel.aOCSubsequent",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "camel.AOCSubsequent", HFILL }},
     { &hf_camel_cAI_GSM0224,
       { "cAI-GSM0224", "camel.cAI_GSM0224",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AOCSubsequent/cAI-GSM0224", HFILL }},
+        "camel.CAI_Gsm0224", HFILL }},
     { &hf_camel_tone,
       { "tone", "camel.tone",
         FT_BOOLEAN, 8, NULL, 0,
-        "AudibleIndicator/tone", HFILL }},
+        "camel.BOOLEAN", HFILL }},
     { &hf_camel_burstList,
       { "burstList", "camel.burstList",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AudibleIndicator/burstList", HFILL }},
+        "camel.BurstList", HFILL }},
     { &hf_camel_conferenceTreatmentIndicator,
       { "conferenceTreatmentIndicator", "camel.conferenceTreatmentIndicator",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.OCTET_STRING_SIZE_1", HFILL }},
     { &hf_camel_callCompletionTreatmentIndicator,
       { "callCompletionTreatmentIndicator", "camel.callCompletionTreatmentIndicator",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "BackwardServiceInteractionInd/callCompletionTreatmentIndicator", HFILL }},
+        "camel.OCTET_STRING_SIZE_1", HFILL }},
     { &hf_camel_calledAddressValue,
       { "calledAddressValue", "camel.calledAddressValue",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.Digits", HFILL }},
     { &hf_camel_gapOnService,
       { "gapOnService", "camel.gapOnService",
         FT_NONE, BASE_NONE, NULL, 0,
-        "BasicGapCriteria/gapOnService", HFILL }},
+        "camel.GapOnService", HFILL }},
     { &hf_camel_calledAddressAndService,
       { "calledAddressAndService", "camel.calledAddressAndService",
         FT_NONE, BASE_NONE, NULL, 0,
-        "BasicGapCriteria/calledAddressAndService", HFILL }},
+        "camel.T_calledAddressAndService", HFILL }},
     { &hf_camel_serviceKey,
       { "serviceKey", "camel.serviceKey",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "camel.ServiceKey", HFILL }},
     { &hf_camel_callingAddressAndService,
       { "callingAddressAndService", "camel.callingAddressAndService",
         FT_NONE, BASE_NONE, NULL, 0,
-        "BasicGapCriteria/callingAddressAndService", HFILL }},
+        "camel.T_callingAddressAndService", HFILL }},
     { &hf_camel_callingAddressValue,
       { "callingAddressValue", "camel.callingAddressValue",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "BasicGapCriteria/callingAddressAndService/callingAddressValue", HFILL }},
+        "camel.Digits", HFILL }},
     { &hf_camel_eventTypeBCSM,
       { "eventTypeBCSM", "camel.eventTypeBCSM",
         FT_UINT32, BASE_DEC, VALS(camel_EventTypeBCSM_vals), 0,
-        "", HFILL }},
+        "camel.EventTypeBCSM", HFILL }},
     { &hf_camel_monitorMode,
       { "monitorMode", "camel.monitorMode",
         FT_UINT32, BASE_DEC, VALS(camel_MonitorMode_vals), 0,
-        "", HFILL }},
+        "camel.MonitorMode", HFILL }},
     { &hf_camel_legID6,
       { "legID6", "camel.legID6",
         FT_UINT32, BASE_DEC, VALS(camel_LegID_vals), 0,
-        "BCSMEvent/legID6", HFILL }},
+        "camel.LegID", HFILL }},
     { &hf_camel_dpSpecificCriteria,
       { "dpSpecificCriteria", "camel.dpSpecificCriteria",
         FT_UINT32, BASE_DEC, VALS(camel_DpSpecificCriteria_vals), 0,
-        "BCSMEvent/dpSpecificCriteria", HFILL }},
+        "camel.DpSpecificCriteria", HFILL }},
     { &hf_camel_automaticRearm,
       { "automaticRearm", "camel.automaticRearm",
         FT_NONE, BASE_NONE, NULL, 0,
-        "BCSMEvent/automaticRearm", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_cause,
       { "cause", "camel.cause",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.Cause", HFILL }},
     { &hf_camel_bearerCap,
       { "bearerCap", "camel.bearerCap",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "BearerCapability/bearerCap", HFILL }},
+        "camel.BearerCap", HFILL }},
     { &hf_camel_numberOfBursts,
       { "numberOfBursts", "camel.numberOfBursts",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Burst/numberOfBursts", HFILL }},
+        "camel.INTEGER_1_3", HFILL }},
     { &hf_camel_burstInterval,
       { "burstInterval", "camel.burstInterval",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Burst/burstInterval", HFILL }},
+        "camel.INTEGER_1_1200", HFILL }},
     { &hf_camel_numberOfTonesInBurst,
       { "numberOfTonesInBurst", "camel.numberOfTonesInBurst",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Burst/numberOfTonesInBurst", HFILL }},
+        "camel.INTEGER_1_3", HFILL }},
     { &hf_camel_toneDuration,
       { "toneDuration", "camel.toneDuration",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Burst/toneDuration", HFILL }},
+        "camel.INTEGER_1_20", HFILL }},
     { &hf_camel_toneInterval,
       { "toneInterval", "camel.toneInterval",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Burst/toneInterval", HFILL }},
+        "camel.INTEGER_1_20", HFILL }},
     { &hf_camel_warningPeriod,
       { "warningPeriod", "camel.warningPeriod",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "BurstList/warningPeriod", HFILL }},
+        "camel.INTEGER_1_1200", HFILL }},
     { &hf_camel_bursts,
       { "bursts", "camel.bursts",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "camel.Burst", HFILL }},
     { &hf_camel_e1,
       { "e1", "camel.e1",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CAI-Gsm0224/e1", HFILL }},
+        "camel.INTEGER_0_8191", HFILL }},
     { &hf_camel_e2,
       { "e2", "camel.e2",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CAI-Gsm0224/e2", HFILL }},
+        "camel.INTEGER_0_8191", HFILL }},
     { &hf_camel_e3,
       { "e3", "camel.e3",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CAI-Gsm0224/e3", HFILL }},
+        "camel.INTEGER_0_8191", HFILL }},
     { &hf_camel_e4,
       { "e4", "camel.e4",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CAI-Gsm0224/e4", HFILL }},
+        "camel.INTEGER_0_8191", HFILL }},
     { &hf_camel_e5,
       { "e5", "camel.e5",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CAI-Gsm0224/e5", HFILL }},
+        "camel.INTEGER_0_8191", HFILL }},
     { &hf_camel_e6,
       { "e6", "camel.e6",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CAI-Gsm0224/e6", HFILL }},
+        "camel.INTEGER_0_8191", HFILL }},
     { &hf_camel_e7,
       { "e7", "camel.e7",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CAI-Gsm0224/e7", HFILL }},
+        "camel.INTEGER_0_8191", HFILL }},
     { &hf_camel_callSegmentID,
       { "callSegmentID", "camel.callSegmentID",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "camel.CallSegmentID", HFILL }},
     { &hf_camel_invokeID,
       { "invokeID", "camel.invokeID",
         FT_INT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "camel.InvokeID", HFILL }},
     { &hf_camel_timeDurationCharging,
       { "timeDurationCharging", "camel.timeDurationCharging",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CAMEL-AChBillingChargingCharacteristics/timeDurationCharging", HFILL }},
+        "camel.T_timeDurationCharging", HFILL }},
     { &hf_camel_audibleIndicator,
       { "audibleIndicator", "camel.audibleIndicator",
         FT_UINT32, BASE_DEC, VALS(camel_AudibleIndicator_vals), 0,
-        "CAMEL-AChBillingChargingCharacteristics/timeDurationCharging/audibleIndicator", HFILL }},
+        "camel.AudibleIndicator", HFILL }},
     { &hf_camel_timeDurationChargingResult,
       { "timeDurationChargingResult", "camel.timeDurationChargingResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CAMEL-CallResult/timeDurationChargingResult", HFILL }},
+        "camel.T_timeDurationChargingResult", HFILL }},
     { &hf_camel_partyToCharge,
       { "partyToCharge", "camel.partyToCharge",
         FT_UINT32, BASE_DEC, VALS(camel_ReceivingSideID_vals), 0,
-        "CAMEL-CallResult/timeDurationChargingResult/partyToCharge", HFILL }},
+        "camel.ReceivingSideID", HFILL }},
     { &hf_camel_timeInformation,
       { "timeInformation", "camel.timeInformation",
         FT_UINT32, BASE_DEC, VALS(camel_TimeInformation_vals), 0,
-        "CAMEL-CallResult/timeDurationChargingResult/timeInformation", HFILL }},
+        "camel.TimeInformation", HFILL }},
     { &hf_camel_legActive,
       { "legActive", "camel.legActive",
         FT_BOOLEAN, 8, NULL, 0,
-        "CAMEL-CallResult/timeDurationChargingResult/legActive", HFILL }},
+        "camel.BOOLEAN", HFILL }},
     { &hf_camel_callLegReleasedAtTcpExpiry,
       { "callLegReleasedAtTcpExpiry", "camel.callLegReleasedAtTcpExpiry",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CAMEL-CallResult/timeDurationChargingResult/callLegReleasedAtTcpExpiry", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_extensions1,
       { "extensions", "camel.extensions",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "camel.Extensions", HFILL }},
     { &hf_camel_aChChargingAddress,
       { "aChChargingAddress", "camel.aChChargingAddress",
         FT_UINT32, BASE_DEC, VALS(camel_AChChargingAddress_vals), 0,
-        "", HFILL }},
+        "camel.AChChargingAddress", HFILL }},
     { &hf_camel_fCIBCCCAMELsequence1,
       { "fCIBCCCAMELsequence1", "camel.fCIBCCCAMELsequence1",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CAMEL-FCIBillingChargingCharacteristics/fCIBCCCAMELsequence1", HFILL }},
+        "camel.T_fCIBCCCAMELsequence1", HFILL }},
     { &hf_camel_freeFormatData,
       { "freeFormatData", "camel.freeFormatData",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.FreeFormatData", HFILL }},
     { &hf_camel_partyToCharge4,
       { "partyToCharge4", "camel.partyToCharge4",
         FT_UINT32, BASE_DEC, VALS(camel_SendingSideID_vals), 0,
-        "CAMEL-FCIBillingChargingCharacteristics/fCIBCCCAMELsequence1/partyToCharge4", HFILL }},
+        "camel.SendingSideID", HFILL }},
     { &hf_camel_appendFreeFormatData,
       { "appendFreeFormatData", "camel.appendFreeFormatData",
         FT_UINT32, BASE_DEC, VALS(camel_AppendFreeFormatData_vals), 0,
-        "", HFILL }},
+        "camel.AppendFreeFormatData", HFILL }},
     { &hf_camel_fCIBCCCAMELsequence2,
       { "fCIBCCCAMELsequence2", "camel.fCIBCCCAMELsequence2",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CAMEL-FCIGPRSBillingChargingCharacteristics/fCIBCCCAMELsequence2", HFILL }},
+        "camel.T_fCIBCCCAMELsequence2", HFILL }},
     { &hf_camel_pDPID,
       { "pDPID", "camel.pDPID",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.PDPId", HFILL }},
     { &hf_camel_fCIBCCCAMELsequence3,
       { "fCIBCCCAMELsequence3", "camel.fCIBCCCAMELsequence3",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CAMEL-FCISMSBillingChargingCharacteristics/fCIBCCCAMELsequence3", HFILL }},
+        "camel.T_fCIBCCCAMELsequence3", HFILL }},
     { &hf_camel_aOCBeforeAnswer,
       { "aOCBeforeAnswer", "camel.aOCBeforeAnswer",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CAMEL-SCIBillingChargingCharacteristics/aOCBeforeAnswer", HFILL }},
+        "camel.AOCBeforeAnswer", HFILL }},
     { &hf_camel_aOCAfterAnswer,
       { "aOCAfterAnswer", "camel.aOCAfterAnswer",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CAMEL-SCIBillingChargingCharacteristics/aOCAfterAnswer", HFILL }},
+        "camel.AOCSubsequent", HFILL }},
     { &hf_camel_aOC_extension,
       { "aOC-extension", "camel.aOC_extension",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CAMEL-SCIBillingChargingCharacteristics/aOC-extension", HFILL }},
+        "camel.CAMEL_SCIBillingChargingCharacteristicsAlt", HFILL }},
     { &hf_camel_aOCGPRS,
       { "aOCGPRS", "camel.aOCGPRS",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CamelSCIGPRSBillingChargingCharacteristics/aOCGPRS", HFILL }},
+        "camel.AOCGprs", HFILL }},
     { &hf_camel_ChangeOfPositionControlInfo_item,
       { "Item", "camel.ChangeOfPositionControlInfo_item",
         FT_UINT32, BASE_DEC, VALS(camel_ChangeOfLocation_vals), 0,
-        "ChangeOfPositionControlInfo/_item", HFILL }},
+        "camel.ChangeOfLocation", HFILL }},
     { &hf_camel_cellGlobalId,
       { "cellGlobalId", "camel.cellGlobalId",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "ChangeOfLocation/cellGlobalId", HFILL }},
+        "gsm_map.CellGlobalIdOrServiceAreaIdFixedLength", HFILL }},
     { &hf_camel_serviceAreaId,
       { "serviceAreaId", "camel.serviceAreaId",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "ChangeOfLocation/serviceAreaId", HFILL }},
+        "gsm_map.CellGlobalIdOrServiceAreaIdFixedLength", HFILL }},
     { &hf_camel_locationAreaId,
       { "locationAreaId", "camel.locationAreaId",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "ChangeOfLocation/locationAreaId", HFILL }},
+        "gsm_map.LAIFixedLength", HFILL }},
     { &hf_camel_inter_SystemHandOver,
       { "inter-SystemHandOver", "camel.inter_SystemHandOver",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ChangeOfLocation/inter-SystemHandOver", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_inter_PLMNHandOver,
       { "inter-PLMNHandOver", "camel.inter_PLMNHandOver",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_inter_MSCHandOver,
       { "inter-MSCHandOver", "camel.inter_MSCHandOver",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_changeOfLocationAlt,
       { "changeOfLocationAlt", "camel.changeOfLocationAlt",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ChangeOfLocation/changeOfLocationAlt", HFILL }},
+        "camel.ChangeOfLocationAlt", HFILL }},
     { &hf_camel_maxTransferredVolume,
       { "maxTransferredVolume", "camel.maxTransferredVolume",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ChargingCharacteristics/maxTransferredVolume", HFILL }},
+        "camel.INTEGER_1_2147483647", HFILL }},
     { &hf_camel_maxElapsedTime,
       { "maxElapsedTime", "camel.maxElapsedTime",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ChargingCharacteristics/maxElapsedTime", HFILL }},
+        "camel.INTEGER_1_86400", HFILL }},
     { &hf_camel_transferredVolume,
       { "transferredVolume", "camel.transferredVolume",
         FT_UINT32, BASE_DEC, VALS(camel_TransferredVolume_vals), 0,
-        "ChargingResult/transferredVolume", HFILL }},
+        "camel.TransferredVolume", HFILL }},
     { &hf_camel_elapsedTime,
       { "elapsedTime", "camel.elapsedTime",
         FT_UINT32, BASE_DEC, VALS(camel_ElapsedTime_vals), 0,
-        "ChargingResult/elapsedTime", HFILL }},
+        "camel.ElapsedTime", HFILL }},
     { &hf_camel_transferredVolumeRollOver,
       { "transferredVolumeRollOver", "camel.transferredVolumeRollOver",
         FT_UINT32, BASE_DEC, VALS(camel_TransferredVolumeRollOver_vals), 0,
-        "ChargingRollOver/transferredVolumeRollOver", HFILL }},
+        "camel.TransferredVolumeRollOver", HFILL }},
     { &hf_camel_elapsedTimeRollOver,
       { "elapsedTimeRollOver", "camel.elapsedTimeRollOver",
         FT_UINT32, BASE_DEC, VALS(camel_ElapsedTimeRollOver_vals), 0,
-        "ChargingRollOver/elapsedTimeRollOver", HFILL }},
+        "camel.ElapsedTimeRollOver", HFILL }},
     { &hf_camel_minimumNbOfDigits,
       { "minimumNbOfDigits", "camel.minimumNbOfDigits",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CollectedDigits/minimumNbOfDigits", HFILL }},
+        "camel.INTEGER_1_30", HFILL }},
     { &hf_camel_maximumNbOfDigits,
       { "maximumNbOfDigits", "camel.maximumNbOfDigits",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CollectedDigits/maximumNbOfDigits", HFILL }},
+        "camel.INTEGER_1_30", HFILL }},
     { &hf_camel_endOfReplyDigit,
       { "endOfReplyDigit", "camel.endOfReplyDigit",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.OCTET_STRING_SIZE_1_2", HFILL }},
     { &hf_camel_cancelDigit,
       { "cancelDigit", "camel.cancelDigit",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.OCTET_STRING_SIZE_1_2", HFILL }},
     { &hf_camel_startDigit,
       { "startDigit", "camel.startDigit",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.OCTET_STRING_SIZE_1_2", HFILL }},
     { &hf_camel_firstDigitTimeOut,
       { "firstDigitTimeOut", "camel.firstDigitTimeOut",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CollectedDigits/firstDigitTimeOut", HFILL }},
+        "camel.INTEGER_1_127", HFILL }},
     { &hf_camel_interDigitTimeOut,
       { "interDigitTimeOut", "camel.interDigitTimeOut",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CollectedDigits/interDigitTimeOut", HFILL }},
+        "camel.INTEGER_1_127", HFILL }},
     { &hf_camel_errorTreatment,
       { "errorTreatment", "camel.errorTreatment",
         FT_UINT32, BASE_DEC, VALS(camel_ErrorTreatment_vals), 0,
-        "CollectedDigits/errorTreatment", HFILL }},
+        "camel.ErrorTreatment", HFILL }},
     { &hf_camel_interruptableAnnInd,
       { "interruptableAnnInd", "camel.interruptableAnnInd",
         FT_BOOLEAN, 8, NULL, 0,
-        "CollectedDigits/interruptableAnnInd", HFILL }},
+        "camel.BOOLEAN", HFILL }},
     { &hf_camel_voiceInformation,
       { "voiceInformation", "camel.voiceInformation",
         FT_BOOLEAN, 8, NULL, 0,
-        "CollectedDigits/voiceInformation", HFILL }},
+        "camel.BOOLEAN", HFILL }},
     { &hf_camel_voiceBack,
       { "voiceBack", "camel.voiceBack",
         FT_BOOLEAN, 8, NULL, 0,
-        "CollectedDigits/voiceBack", HFILL }},
+        "camel.BOOLEAN", HFILL }},
     { &hf_camel_collectedDigits,
       { "collectedDigits", "camel.collectedDigits",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CollectedInfo/collectedDigits", HFILL }},
+        "camel.CollectedDigits", HFILL }},
     { &hf_camel_basicGapCriteria,
       { "basicGapCriteria", "camel.basicGapCriteria",
         FT_UINT32, BASE_DEC, VALS(camel_BasicGapCriteria_vals), 0,
-        "", HFILL }},
+        "camel.BasicGapCriteria", HFILL }},
     { &hf_camel_scfID,
       { "scfID", "camel.scfID",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.ScfID", HFILL }},
     { &hf_camel_DestinationRoutingAddress_item,
       { "Item", "camel.DestinationRoutingAddress_item",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "DestinationRoutingAddress/_item", HFILL }},
+        "camel.CalledPartyNumber", HFILL }},
     { &hf_camel_applicationTimer,
       { "applicationTimer", "camel.applicationTimer",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "DpSpecificCriteria/applicationTimer", HFILL }},
+        "camel.ApplicationTimer", HFILL }},
     { &hf_camel_midCallControlInfo,
       { "midCallControlInfo", "camel.midCallControlInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "DpSpecificCriteria/midCallControlInfo", HFILL }},
+        "camel.MidCallControlInfo", HFILL }},
     { &hf_camel_dpSpecificCriteriaAlt,
       { "dpSpecificCriteriaAlt", "camel.dpSpecificCriteriaAlt",
         FT_NONE, BASE_NONE, NULL, 0,
-        "DpSpecificCriteria/dpSpecificCriteriaAlt", HFILL }},
+        "camel.DpSpecificCriteriaAlt", HFILL }},
     { &hf_camel_changeOfPositionControlInfo,
       { "changeOfPositionControlInfo", "camel.changeOfPositionControlInfo",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "DpSpecificCriteriaAlt/changeOfPositionControlInfo", HFILL }},
+        "camel.ChangeOfPositionControlInfo", HFILL }},
     { &hf_camel_oServiceChangeSpecificInfo,
       { "oServiceChangeSpecificInfo", "camel.oServiceChangeSpecificInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "DpSpecificInfoAlt/oServiceChangeSpecificInfo", HFILL }},
+        "camel.T_oServiceChangeSpecificInfo", HFILL }},
     { &hf_camel_ext_basicServiceCode,
       { "ext-basicServiceCode", "camel.ext_basicServiceCode",
         FT_UINT32, BASE_DEC, VALS(gsm_map_Ext_BasicServiceCode_vals), 0,
-        "", HFILL }},
+        "gsm_map.Ext_BasicServiceCode", HFILL }},
     { &hf_camel_tServiceChangeSpecificInfo,
       { "tServiceChangeSpecificInfo", "camel.tServiceChangeSpecificInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "DpSpecificInfoAlt/tServiceChangeSpecificInfo", HFILL }},
+        "camel.T_tServiceChangeSpecificInfo", HFILL }},
     { &hf_camel_timeGPRSIfNoTariffSwitch,
       { "timeGPRSIfNoTariffSwitch", "camel.timeGPRSIfNoTariffSwitch",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ElapsedTime/timeGPRSIfNoTariffSwitch", HFILL }},
+        "camel.INTEGER_0_86400", HFILL }},
     { &hf_camel_timeGPRSIfTariffSwitch,
       { "timeGPRSIfTariffSwitch", "camel.timeGPRSIfTariffSwitch",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ElapsedTime/timeGPRSIfTariffSwitch", HFILL }},
+        "camel.T_timeGPRSIfTariffSwitch", HFILL }},
     { &hf_camel_timeGPRSSinceLastTariffSwitch,
       { "timeGPRSSinceLastTariffSwitch", "camel.timeGPRSSinceLastTariffSwitch",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ElapsedTime/timeGPRSIfTariffSwitch/timeGPRSSinceLastTariffSwitch", HFILL }},
+        "camel.INTEGER_0_86400", HFILL }},
     { &hf_camel_timeGPRSTariffSwitchInterval,
       { "timeGPRSTariffSwitchInterval", "camel.timeGPRSTariffSwitchInterval",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ElapsedTime/timeGPRSIfTariffSwitch/timeGPRSTariffSwitchInterval", HFILL }},
+        "camel.INTEGER_0_86400", HFILL }},
     { &hf_camel_rOTimeGPRSIfNoTariffSwitch,
       { "rOTimeGPRSIfNoTariffSwitch", "camel.rOTimeGPRSIfNoTariffSwitch",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ElapsedTimeRollOver/rOTimeGPRSIfNoTariffSwitch", HFILL }},
+        "camel.INTEGER_0_255", HFILL }},
     { &hf_camel_rOTimeGPRSIfTariffSwitch,
       { "rOTimeGPRSIfTariffSwitch", "camel.rOTimeGPRSIfTariffSwitch",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ElapsedTimeRollOver/rOTimeGPRSIfTariffSwitch", HFILL }},
+        "camel.T_rOTimeGPRSIfTariffSwitch", HFILL }},
     { &hf_camel_rOTimeGPRSSinceLastTariffSwitch,
       { "rOTimeGPRSSinceLastTariffSwitch", "camel.rOTimeGPRSSinceLastTariffSwitch",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ElapsedTimeRollOver/rOTimeGPRSIfTariffSwitch/rOTimeGPRSSinceLastTariffSwitch", HFILL }},
+        "camel.INTEGER_0_255", HFILL }},
     { &hf_camel_rOTimeGPRSTariffSwitchInterval,
       { "rOTimeGPRSTariffSwitchInterval", "camel.rOTimeGPRSTariffSwitchInterval",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ElapsedTimeRollOver/rOTimeGPRSIfTariffSwitch/rOTimeGPRSTariffSwitchInterval", HFILL }},
+        "camel.INTEGER_0_255", HFILL }},
     { &hf_camel_pDPTypeOrganization,
       { "pDPTypeOrganization", "camel.pDPTypeOrganization",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "EndUserAddress/pDPTypeOrganization", HFILL }},
+        "camel.OCTET_STRING_SIZE_1", HFILL }},
     { &hf_camel_pDPTypeNumber,
       { "pDPTypeNumber", "camel.pDPTypeNumber",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "EndUserAddress/pDPTypeNumber", HFILL }},
+        "camel.OCTET_STRING_SIZE_1", HFILL }},
     { &hf_camel_pDPAddress,
       { "pDPAddress", "camel.pDPAddress",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "EndUserAddress/pDPAddress", HFILL }},
+        "camel.OCTET_STRING_SIZE_1_63", HFILL }},
     { &hf_camel_routeSelectFailureSpecificInfo,
       { "routeSelectFailureSpecificInfo", "camel.routeSelectFailureSpecificInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventSpecificInformationBCSM/routeSelectFailureSpecificInfo", HFILL }},
+        "camel.T_routeSelectFailureSpecificInfo", HFILL }},
     { &hf_camel_failureCause,
       { "failureCause", "camel.failureCause",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "EventSpecificInformationBCSM/routeSelectFailureSpecificInfo/failureCause", HFILL }},
+        "camel.Cause", HFILL }},
     { &hf_camel_oCalledPartyBusySpecificInfo,
       { "oCalledPartyBusySpecificInfo", "camel.oCalledPartyBusySpecificInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventSpecificInformationBCSM/oCalledPartyBusySpecificInfo", HFILL }},
+        "camel.T_oCalledPartyBusySpecificInfo", HFILL }},
     { &hf_camel_busyCause,
       { "busyCause", "camel.busyCause",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.Cause", HFILL }},
     { &hf_camel_oNoAnswerSpecificInfo,
       { "oNoAnswerSpecificInfo", "camel.oNoAnswerSpecificInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventSpecificInformationBCSM/oNoAnswerSpecificInfo", HFILL }},
+        "camel.T_oNoAnswerSpecificInfo", HFILL }},
     { &hf_camel_oAnswerSpecificInfo,
       { "oAnswerSpecificInfo", "camel.oAnswerSpecificInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventSpecificInformationBCSM/oAnswerSpecificInfo", HFILL }},
+        "camel.T_oAnswerSpecificInfo", HFILL }},
     { &hf_camel_destinationAddress,
       { "destinationAddress", "camel.destinationAddress",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.CalledPartyNumber", HFILL }},
     { &hf_camel_or_Call,
       { "or-Call", "camel.or_Call",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_forwardedCall,
       { "forwardedCall", "camel.forwardedCall",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_chargeIndicator,
       { "chargeIndicator", "camel.chargeIndicator",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.ChargeIndicator", HFILL }},
     { &hf_camel_ext_basicServiceCode2,
       { "ext-basicServiceCode2", "camel.ext_basicServiceCode2",
         FT_UINT32, BASE_DEC, VALS(gsm_map_Ext_BasicServiceCode_vals), 0,
-        "", HFILL }},
+        "gsm_map.Ext_BasicServiceCode", HFILL }},
     { &hf_camel_oMidCallSpecificInfo,
       { "oMidCallSpecificInfo", "camel.oMidCallSpecificInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventSpecificInformationBCSM/oMidCallSpecificInfo", HFILL }},
+        "camel.T_oMidCallSpecificInfo", HFILL }},
     { &hf_camel_midCallEvents,
       { "midCallEvents", "camel.midCallEvents",
         FT_UINT32, BASE_DEC, VALS(camel_T_midCallEvents_vals), 0,
-        "EventSpecificInformationBCSM/oMidCallSpecificInfo/midCallEvents", HFILL }},
+        "camel.T_midCallEvents", HFILL }},
     { &hf_camel_dTMFDigitsCompleted,
       { "dTMFDigitsCompleted", "camel.dTMFDigitsCompleted",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.Digits", HFILL }},
     { &hf_camel_dTMFDigitsTimeOut,
       { "dTMFDigitsTimeOut", "camel.dTMFDigitsTimeOut",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.Digits", HFILL }},
     { &hf_camel_oDisconnectSpecificInfo,
       { "oDisconnectSpecificInfo", "camel.oDisconnectSpecificInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventSpecificInformationBCSM/oDisconnectSpecificInfo", HFILL }},
+        "camel.T_oDisconnectSpecificInfo", HFILL }},
     { &hf_camel_releaseCause,
       { "releaseCause", "camel.releaseCause",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.Cause", HFILL }},
     { &hf_camel_tBusySpecificInfo,
       { "tBusySpecificInfo", "camel.tBusySpecificInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventSpecificInformationBCSM/tBusySpecificInfo", HFILL }},
+        "camel.T_tBusySpecificInfo", HFILL }},
     { &hf_camel_callForwarded,
       { "callForwarded", "camel.callForwarded",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_routeNotPermitted,
       { "routeNotPermitted", "camel.routeNotPermitted",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_forwardingDestinationNumber,
       { "forwardingDestinationNumber", "camel.forwardingDestinationNumber",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.CalledPartyNumber", HFILL }},
     { &hf_camel_tNoAnswerSpecificInfo,
       { "tNoAnswerSpecificInfo", "camel.tNoAnswerSpecificInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventSpecificInformationBCSM/tNoAnswerSpecificInfo", HFILL }},
+        "camel.T_tNoAnswerSpecificInfo", HFILL }},
     { &hf_camel_tAnswerSpecificInfo,
       { "tAnswerSpecificInfo", "camel.tAnswerSpecificInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventSpecificInformationBCSM/tAnswerSpecificInfo", HFILL }},
+        "camel.T_tAnswerSpecificInfo", HFILL }},
     { &hf_camel_tMidCallSpecificInfo,
       { "tMidCallSpecificInfo", "camel.tMidCallSpecificInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventSpecificInformationBCSM/tMidCallSpecificInfo", HFILL }},
+        "camel.T_tMidCallSpecificInfo", HFILL }},
     { &hf_camel_midCallEvents1,
       { "midCallEvents", "camel.midCallEvents",
         FT_UINT32, BASE_DEC, VALS(camel_T_midCallEvents1_vals), 0,
-        "EventSpecificInformationBCSM/tMidCallSpecificInfo/midCallEvents", HFILL }},
+        "camel.T_midCallEvents1", HFILL }},
     { &hf_camel_tDisconnectSpecificInfo,
       { "tDisconnectSpecificInfo", "camel.tDisconnectSpecificInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventSpecificInformationBCSM/tDisconnectSpecificInfo", HFILL }},
+        "camel.T_tDisconnectSpecificInfo", HFILL }},
     { &hf_camel_oTermSeizedSpecificInfo,
       { "oTermSeizedSpecificInfo", "camel.oTermSeizedSpecificInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventSpecificInformationBCSM/oTermSeizedSpecificInfo", HFILL }},
+        "camel.T_oTermSeizedSpecificInfo", HFILL }},
     { &hf_camel_locationInformation,
       { "locationInformation", "camel.locationInformation",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "gsm_map.LocationInformation", HFILL }},
     { &hf_camel_callAcceptedSpecificInfo,
       { "callAcceptedSpecificInfo", "camel.callAcceptedSpecificInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventSpecificInformationBCSM/callAcceptedSpecificInfo", HFILL }},
+        "camel.T_callAcceptedSpecificInfo", HFILL }},
     { &hf_camel_oAbandonSpecificInfo,
       { "oAbandonSpecificInfo", "camel.oAbandonSpecificInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventSpecificInformationBCSM/oAbandonSpecificInfo", HFILL }},
+        "camel.T_oAbandonSpecificInfo", HFILL }},
     { &hf_camel_oChangeOfPositionSpecificInfo,
       { "oChangeOfPositionSpecificInfo", "camel.oChangeOfPositionSpecificInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventSpecificInformationBCSM/oChangeOfPositionSpecificInfo", HFILL }},
+        "camel.T_oChangeOfPositionSpecificInfo", HFILL }},
     { &hf_camel_metDPCriteriaList,
       { "metDPCriteriaList", "camel.metDPCriteriaList",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "camel.MetDPCriteriaList", HFILL }},
     { &hf_camel_tChangeOfPositionSpecificInfo,
       { "tChangeOfPositionSpecificInfo", "camel.tChangeOfPositionSpecificInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventSpecificInformationBCSM/tChangeOfPositionSpecificInfo", HFILL }},
+        "camel.T_tChangeOfPositionSpecificInfo", HFILL }},
     { &hf_camel_dpSpecificInfoAlt,
       { "dpSpecificInfoAlt", "camel.dpSpecificInfoAlt",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventSpecificInformationBCSM/dpSpecificInfoAlt", HFILL }},
+        "camel.DpSpecificInfoAlt", HFILL }},
     { &hf_camel_o_smsFailureSpecificInfo,
       { "o-smsFailureSpecificInfo", "camel.o_smsFailureSpecificInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventSpecificInformationSMS/o-smsFailureSpecificInfo", HFILL }},
+        "camel.T_o_smsFailureSpecificInfo", HFILL }},
     { &hf_camel_smsfailureCause,
       { "smsfailureCause", "camel.smsfailureCause",
         FT_UINT32, BASE_DEC, VALS(camel_MO_SMSCause_vals), 0,
-        "EventSpecificInformationSMS/o-smsFailureSpecificInfo/smsfailureCause", HFILL }},
+        "camel.MO_SMSCause", HFILL }},
     { &hf_camel_o_smsSubmittedSpecificInfo,
       { "o-smsSubmittedSpecificInfo", "camel.o_smsSubmittedSpecificInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventSpecificInformationSMS/o-smsSubmittedSpecificInfo", HFILL }},
+        "camel.T_o_smsSubmittedSpecificInfo", HFILL }},
     { &hf_camel_foo,
       { "foo", "camel.foo",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "camel.INTEGER_0", HFILL }},
     { &hf_camel_t_smsFailureSpecificInfo,
       { "t-smsFailureSpecificInfo", "camel.t_smsFailureSpecificInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventSpecificInformationSMS/t-smsFailureSpecificInfo", HFILL }},
+        "camel.T_t_smsFailureSpecificInfo", HFILL }},
     { &hf_camel_failureCause1,
       { "failureCause", "camel.failureCause",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "EventSpecificInformationSMS/t-smsFailureSpecificInfo/failureCause", HFILL }},
+        "camel.MT_SMSCause", HFILL }},
     { &hf_camel_t_smsDeliverySpecificInfo,
       { "t-smsDeliverySpecificInfo", "camel.t_smsDeliverySpecificInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventSpecificInformationSMS/t-smsDeliverySpecificInfo", HFILL }},
+        "camel.T_t_smsDeliverySpecificInfo", HFILL }},
     { &hf_camel_Extensions_item,
       { "Item", "camel.Extensions_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Extensions/_item", HFILL }},
+        "camel.ExtensionField", HFILL }},
     { &hf_camel_callDiversionTreatmentIndicator,
       { "callDiversionTreatmentIndicator", "camel.callDiversionTreatmentIndicator",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "ForwardServiceInteractionInd/callDiversionTreatmentIndicator", HFILL }},
+        "camel.OCTET_STRING_SIZE_1", HFILL }},
     { &hf_camel_callingPartyRestrictionIndicator,
       { "callingPartyRestrictionIndicator", "camel.callingPartyRestrictionIndicator",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "ForwardServiceInteractionInd/callingPartyRestrictionIndicator", HFILL }},
+        "camel.OCTET_STRING_SIZE_1", HFILL }},
     { &hf_camel_compoundGapCriteria,
       { "compoundGapCriteria", "camel.compoundGapCriteria",
         FT_NONE, BASE_NONE, NULL, 0,
-        "GapCriteria/compoundGapCriteria", HFILL }},
+        "camel.CompoundCriteria", HFILL }},
     { &hf_camel_duration1,
       { "duration1", "camel.duration1",
         FT_INT32, BASE_DEC, NULL, 0,
-        "GapIndicators/duration1", HFILL }},
+        "camel.Duration", HFILL }},
     { &hf_camel_gapInterval,
       { "gapInterval", "camel.gapInterval",
         FT_INT32, BASE_DEC, NULL, 0,
-        "GapIndicators/gapInterval", HFILL }},
+        "camel.Interval", HFILL }},
     { &hf_camel_informationToSend,
       { "informationToSend", "camel.informationToSend",
         FT_UINT32, BASE_DEC, VALS(camel_InformationToSend_vals), 0,
-        "", HFILL }},
+        "camel.InformationToSend", HFILL }},
     { &hf_camel_GenericNumbers_item,
       { "Item", "camel.GenericNumbers_item",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "GenericNumbers/_item", HFILL }},
+        "camel.GenericNumber", HFILL }},
     { &hf_camel_short_QoS_format,
       { "short-QoS-format", "camel.short_QoS_format",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "GPRS-QoS/short-QoS-format", HFILL }},
+        "gsm_map.QoS_Subscribed", HFILL }},
     { &hf_camel_long_QoS_format,
       { "long-QoS-format", "camel.long_QoS_format",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "GPRS-QoS/long-QoS-format", HFILL }},
+        "gsm_map.Ext_QoS_Subscribed", HFILL }},
     { &hf_camel_supplement_to_long_QoS_format,
       { "supplement-to-long-QoS-format", "camel.supplement_to_long_QoS_format",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "GPRS-QoS-Extension/supplement-to-long-QoS-format", HFILL }},
+        "gsm_map.Ext2_QoS_Subscribed", HFILL }},
     { &hf_camel_gPRSEventType,
       { "gPRSEventType", "camel.gPRSEventType",
         FT_UINT32, BASE_DEC, VALS(camel_GPRSEventType_vals), 0,
-        "", HFILL }},
+        "camel.GPRSEventType", HFILL }},
     { &hf_camel_attachChangeOfPositionSpecificInformation,
       { "attachChangeOfPositionSpecificInformation", "camel.attachChangeOfPositionSpecificInformation",
         FT_NONE, BASE_NONE, NULL, 0,
-        "GPRSEventSpecificInformation/attachChangeOfPositionSpecificInformation", HFILL }},
+        "camel.T_attachChangeOfPositionSpecificInformation", HFILL }},
     { &hf_camel_locationInformationGPRS,
       { "locationInformationGPRS", "camel.locationInformationGPRS",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "camel.LocationInformationGPRS", HFILL }},
     { &hf_camel_pdp_ContextchangeOfPositionSpecificInformation,
       { "pdp-ContextchangeOfPositionSpecificInformation", "camel.pdp_ContextchangeOfPositionSpecificInformation",
         FT_NONE, BASE_NONE, NULL, 0,
-        "GPRSEventSpecificInformation/pdp-ContextchangeOfPositionSpecificInformation", HFILL }},
+        "camel.T_pdp_ContextchangeOfPositionSpecificInformation", HFILL }},
     { &hf_camel_accessPointName,
       { "accessPointName", "camel.accessPointName",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.AccessPointName", HFILL }},
     { &hf_camel_chargingID,
       { "chargingID", "camel.chargingID",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "gsm_map.GPRSChargingID", HFILL }},
     { &hf_camel_pDPType,
       { "pDPType", "camel.pDPType",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "camel.PDPType", HFILL }},
     { &hf_camel_qualityOfService,
       { "qualityOfService", "camel.qualityOfService",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "camel.QualityOfService", HFILL }},
     { &hf_camel_timeAndTimeZone,
       { "timeAndTimeZone", "camel.timeAndTimeZone",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.TimeAndTimezone", HFILL }},
     { &hf_camel_gGSNAddress,
       { "gGSNAddress", "camel.gGSNAddress",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "gsm_map.GSN_Address", HFILL }},
     { &hf_camel_detachSpecificInformation,
       { "detachSpecificInformation", "camel.detachSpecificInformation",
         FT_NONE, BASE_NONE, NULL, 0,
-        "GPRSEventSpecificInformation/detachSpecificInformation", HFILL }},
+        "camel.T_detachSpecificInformation", HFILL }},
     { &hf_camel_inititatingEntity,
       { "inititatingEntity", "camel.inititatingEntity",
         FT_UINT32, BASE_DEC, VALS(camel_InitiatingEntity_vals), 0,
-        "", HFILL }},
+        "camel.InitiatingEntity", HFILL }},
     { &hf_camel_routeingAreaUpdate,
       { "routeingAreaUpdate", "camel.routeingAreaUpdate",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_disconnectSpecificInformation,
       { "disconnectSpecificInformation", "camel.disconnectSpecificInformation",
         FT_NONE, BASE_NONE, NULL, 0,
-        "GPRSEventSpecificInformation/disconnectSpecificInformation", HFILL }},
+        "camel.T_disconnectSpecificInformation", HFILL }},
     { &hf_camel_pDPContextEstablishmentSpecificInformation,
       { "pDPContextEstablishmentSpecificInformation", "camel.pDPContextEstablishmentSpecificInformation",
         FT_NONE, BASE_NONE, NULL, 0,
-        "GPRSEventSpecificInformation/pDPContextEstablishmentSpecificInformation", HFILL }},
+        "camel.T_pDPContextEstablishmentSpecificInformation", HFILL }},
     { &hf_camel_pDPInitiationType,
       { "pDPInitiationType", "camel.pDPInitiationType",
         FT_UINT32, BASE_DEC, VALS(camel_PDPInitiationType_vals), 0,
-        "", HFILL }},
+        "camel.PDPInitiationType", HFILL }},
     { &hf_camel_secondaryPDPContext,
       { "secondaryPDPContext", "camel.secondaryPDPContext",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_pDPContextEstablishmentAcknowledgementSpecificInformation,
       { "pDPContextEstablishmentAcknowledgementSpecificInformation", "camel.pDPContextEstablishmentAcknowledgementSpecificInformation",
         FT_NONE, BASE_NONE, NULL, 0,
-        "GPRSEventSpecificInformation/pDPContextEstablishmentAcknowledgementSpecificInformation", HFILL }},
+        "camel.T_pDPContextEstablishmentAcknowledgementSpecificInformation", HFILL }},
     { &hf_camel_mSNetworkCapability,
       { "mSNetworkCapability", "camel.mSNetworkCapability",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "GPRSMSClass/mSNetworkCapability", HFILL }},
+        "camel.MSNetworkCapability", HFILL }},
     { &hf_camel_mSRadioAccessCapability,
       { "mSRadioAccessCapability", "camel.mSRadioAccessCapability",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "GPRSMSClass/mSRadioAccessCapability", HFILL }},
+        "camel.MSRadioAccessCapability", HFILL }},
     { &hf_camel_messageID,
       { "messageID", "camel.messageID",
         FT_UINT32, BASE_DEC, VALS(camel_MessageID_vals), 0,
-        "InbandInfo/messageID", HFILL }},
+        "camel.MessageID", HFILL }},
     { &hf_camel_numberOfRepetitions,
       { "numberOfRepetitions", "camel.numberOfRepetitions",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "InbandInfo/numberOfRepetitions", HFILL }},
+        "camel.INTEGER_1_127", HFILL }},
     { &hf_camel_duration2,
       { "duration2", "camel.duration2",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "InbandInfo/duration2", HFILL }},
+        "camel.INTEGER_0_32767", HFILL }},
     { &hf_camel_interval,
       { "interval", "camel.interval",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "InbandInfo/interval", HFILL }},
+        "camel.INTEGER_0_32767", HFILL }},
     { &hf_camel_inbandInfo,
       { "inbandInfo", "camel.inbandInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "InformationToSend/inbandInfo", HFILL }},
+        "camel.InbandInfo", HFILL }},
     { &hf_camel_tone1,
       { "tone", "camel.tone",
         FT_NONE, BASE_NONE, NULL, 0,
-        "InformationToSend/tone", HFILL }},
+        "camel.Tone", HFILL }},
     { &hf_camel_cellGlobalIdOrServiceAreaIdOrLAI,
       { "cellGlobalIdOrServiceAreaIdOrLAI", "camel.cellGlobalIdOrServiceAreaIdOrLAI",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "LocationInformationGPRS/cellGlobalIdOrServiceAreaIdOrLAI", HFILL }},
+        "camel.CellGlobalIdOrServiceAreaIdOrLAI", HFILL }},
     { &hf_camel_routeingAreaIdentity,
       { "routeingAreaIdentity", "camel.routeingAreaIdentity",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "gsm_map.RAIdentity", HFILL }},
     { &hf_camel_geographicalInformation,
       { "geographicalInformation", "camel.geographicalInformation",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "LocationInformationGPRS/geographicalInformation", HFILL }},
+        "gsm_map.GeographicalInformation", HFILL }},
     { &hf_camel_sgsn_Number,
       { "sgsn-Number", "camel.sgsn_Number",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "LocationInformationGPRS/sgsn-Number", HFILL }},
+        "camel.ISDN_AddressString", HFILL }},
     { &hf_camel_selectedLSAIdentity,
       { "selectedLSAIdentity", "camel.selectedLSAIdentity",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "LocationInformationGPRS/selectedLSAIdentity", HFILL }},
+        "gsm_map.LSAIdentity", HFILL }},
     { &hf_camel_extensionContainer,
       { "extensionContainer", "camel.extensionContainer",
         FT_NONE, BASE_NONE, NULL, 0,
-        "LocationInformationGPRS/extensionContainer", HFILL }},
+        "camel.ExtensionContainer", HFILL }},
     { &hf_camel_saiPresent,
       { "saiPresent", "camel.saiPresent",
         FT_NONE, BASE_NONE, NULL, 0,
-        "LocationInformationGPRS/saiPresent", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_elementaryMessageID,
       { "elementaryMessageID", "camel.elementaryMessageID",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "camel.Integer4", HFILL }},
     { &hf_camel_text,
       { "text", "camel.text",
         FT_NONE, BASE_NONE, NULL, 0,
-        "MessageID/text", HFILL }},
+        "camel.T_text", HFILL }},
     { &hf_camel_messageContent,
       { "messageContent", "camel.messageContent",
         FT_STRING, BASE_NONE, NULL, 0,
-        "MessageID/text/messageContent", HFILL }},
+        "camel.IA5String_SIZE_1_127", HFILL }},
     { &hf_camel_attributes,
       { "attributes", "camel.attributes",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "MessageID/text/attributes", HFILL }},
+        "camel.OCTET_STRING_SIZE_2_10", HFILL }},
     { &hf_camel_elementaryMessageIDs,
       { "elementaryMessageIDs", "camel.elementaryMessageIDs",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "MessageID/elementaryMessageIDs", HFILL }},
+        "camel.SEQUENCE_SIZE_1_16_OF_Integer4", HFILL }},
     { &hf_camel_elementaryMessageIDs_item,
       { "Item", "camel.elementaryMessageIDs_item",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "MessageID/elementaryMessageIDs/_item", HFILL }},
+        "camel.Integer4", HFILL }},
     { &hf_camel_variableMessage,
       { "variableMessage", "camel.variableMessage",
         FT_NONE, BASE_NONE, NULL, 0,
-        "MessageID/variableMessage", HFILL }},
+        "camel.T_variableMessage", HFILL }},
     { &hf_camel_variableParts,
       { "variableParts", "camel.variableParts",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "MessageID/variableMessage/variableParts", HFILL }},
+        "camel.VariablePartsArray", HFILL }},
     { &hf_camel_MetDPCriteriaList_item,
       { "Item", "camel.MetDPCriteriaList_item",
         FT_UINT32, BASE_DEC, VALS(camel_MetDPCriterion_vals), 0,
-        "MetDPCriteriaList/_item", HFILL }},
+        "camel.MetDPCriterion", HFILL }},
     { &hf_camel_enteringCellGlobalId,
       { "enteringCellGlobalId", "camel.enteringCellGlobalId",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "MetDPCriterion/enteringCellGlobalId", HFILL }},
+        "gsm_map.CellGlobalIdOrServiceAreaIdFixedLength", HFILL }},
     { &hf_camel_leavingCellGlobalId,
       { "leavingCellGlobalId", "camel.leavingCellGlobalId",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "MetDPCriterion/leavingCellGlobalId", HFILL }},
+        "gsm_map.CellGlobalIdOrServiceAreaIdFixedLength", HFILL }},
     { &hf_camel_enteringServiceAreaId,
       { "enteringServiceAreaId", "camel.enteringServiceAreaId",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "MetDPCriterion/enteringServiceAreaId", HFILL }},
+        "gsm_map.CellGlobalIdOrServiceAreaIdFixedLength", HFILL }},
     { &hf_camel_leavingServiceAreaId,
       { "leavingServiceAreaId", "camel.leavingServiceAreaId",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "MetDPCriterion/leavingServiceAreaId", HFILL }},
+        "gsm_map.CellGlobalIdOrServiceAreaIdFixedLength", HFILL }},
     { &hf_camel_enteringLocationAreaId,
       { "enteringLocationAreaId", "camel.enteringLocationAreaId",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "MetDPCriterion/enteringLocationAreaId", HFILL }},
+        "gsm_map.LAIFixedLength", HFILL }},
     { &hf_camel_leavingLocationAreaId,
       { "leavingLocationAreaId", "camel.leavingLocationAreaId",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "MetDPCriterion/leavingLocationAreaId", HFILL }},
+        "gsm_map.LAIFixedLength", HFILL }},
     { &hf_camel_inter_SystemHandOverToUMTS,
       { "inter-SystemHandOverToUMTS", "camel.inter_SystemHandOverToUMTS",
         FT_NONE, BASE_NONE, NULL, 0,
-        "MetDPCriterion/inter-SystemHandOverToUMTS", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_inter_SystemHandOverToGSM,
       { "inter-SystemHandOverToGSM", "camel.inter_SystemHandOverToGSM",
         FT_NONE, BASE_NONE, NULL, 0,
-        "MetDPCriterion/inter-SystemHandOverToGSM", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_metDPCriterionAlt,
       { "metDPCriterionAlt", "camel.metDPCriterionAlt",
         FT_NONE, BASE_NONE, NULL, 0,
-        "MetDPCriterion/metDPCriterionAlt", HFILL }},
+        "camel.MetDPCriterionAlt", HFILL }},
     { &hf_camel_minimumNumberOfDigits,
       { "minimumNumberOfDigits", "camel.minimumNumberOfDigits",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "MidCallControlInfo/minimumNumberOfDigits", HFILL }},
+        "camel.INTEGER_1_30", HFILL }},
     { &hf_camel_maximumNumberOfDigits,
       { "maximumNumberOfDigits", "camel.maximumNumberOfDigits",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "MidCallControlInfo/maximumNumberOfDigits", HFILL }},
+        "camel.INTEGER_1_30", HFILL }},
     { &hf_camel_interDigitTimeout,
       { "interDigitTimeout", "camel.interDigitTimeout",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "MidCallControlInfo/interDigitTimeout", HFILL }},
+        "camel.INTEGER_1_127", HFILL }},
     { &hf_camel_requested_QoS,
       { "requested-QoS", "camel.requested_QoS",
         FT_UINT32, BASE_DEC, VALS(camel_GPRS_QoS_vals), 0,
-        "QualityOfService/requested-QoS", HFILL }},
+        "camel.GPRS_QoS", HFILL }},
     { &hf_camel_subscribed_QoS,
       { "subscribed-QoS", "camel.subscribed_QoS",
         FT_UINT32, BASE_DEC, VALS(camel_GPRS_QoS_vals), 0,
-        "QualityOfService/subscribed-QoS", HFILL }},
+        "camel.GPRS_QoS", HFILL }},
     { &hf_camel_negotiated_QoS,
       { "negotiated-QoS", "camel.negotiated_QoS",
         FT_UINT32, BASE_DEC, VALS(camel_GPRS_QoS_vals), 0,
-        "QualityOfService/negotiated-QoS", HFILL }},
+        "camel.GPRS_QoS", HFILL }},
     { &hf_camel_requested_QoS_Extension,
       { "requested-QoS-Extension", "camel.requested_QoS_Extension",
         FT_NONE, BASE_NONE, NULL, 0,
-        "QualityOfService/requested-QoS-Extension", HFILL }},
+        "camel.GPRS_QoS_Extension", HFILL }},
     { &hf_camel_subscribed_QoS_Extension,
       { "subscribed-QoS-Extension", "camel.subscribed_QoS_Extension",
         FT_NONE, BASE_NONE, NULL, 0,
-        "QualityOfService/subscribed-QoS-Extension", HFILL }},
+        "camel.GPRS_QoS_Extension", HFILL }},
     { &hf_camel_negotiated_QoS_Extension,
       { "negotiated-QoS-Extension", "camel.negotiated_QoS_Extension",
         FT_NONE, BASE_NONE, NULL, 0,
-        "QualityOfService/negotiated-QoS-Extension", HFILL }},
+        "camel.GPRS_QoS_Extension", HFILL }},
     { &hf_camel_receivingSideID,
       { "receivingSideID", "camel.receivingSideID",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.LegType", HFILL }},
     { &hf_camel_RequestedInformationList_item,
       { "Item", "camel.RequestedInformationList_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RequestedInformationList/_item", HFILL }},
+        "camel.RequestedInformation", HFILL }},
     { &hf_camel_RequestedInformationTypeList_item,
       { "Item", "camel.RequestedInformationTypeList_item",
         FT_UINT32, BASE_DEC, VALS(camel_RequestedInformationType_vals), 0,
-        "RequestedInformationTypeList/_item", HFILL }},
+        "camel.RequestedInformationType", HFILL }},
     { &hf_camel_requestedInformationType,
       { "requestedInformationType", "camel.requestedInformationType",
         FT_UINT32, BASE_DEC, VALS(camel_RequestedInformationType_vals), 0,
-        "RequestedInformation/requestedInformationType", HFILL }},
+        "camel.RequestedInformationType", HFILL }},
     { &hf_camel_requestedInformationValue,
       { "requestedInformationValue", "camel.requestedInformationValue",
         FT_UINT32, BASE_DEC, VALS(camel_RequestedInformationValue_vals), 0,
-        "RequestedInformation/requestedInformationValue", HFILL }},
+        "camel.RequestedInformationValue", HFILL }},
     { &hf_camel_callAttemptElapsedTimeValue,
       { "callAttemptElapsedTimeValue", "camel.callAttemptElapsedTimeValue",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "RequestedInformationValue/callAttemptElapsedTimeValue", HFILL }},
+        "camel.INTEGER_0_255", HFILL }},
     { &hf_camel_callStopTimeValue,
       { "callStopTimeValue", "camel.callStopTimeValue",
         FT_STRING, NONE, NULL, 0,
-        "RequestedInformationValue/callStopTimeValue", HFILL }},
+        "camel.DateAndTime", HFILL }},
     { &hf_camel_callConnectedElapsedTimeValue,
       { "callConnectedElapsedTimeValue", "camel.callConnectedElapsedTimeValue",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "RequestedInformationValue/callConnectedElapsedTimeValue", HFILL }},
+        "camel.Integer4", HFILL }},
     { &hf_camel_releaseCauseValue,
       { "releaseCauseValue", "camel.releaseCauseValue",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "RequestedInformationValue/releaseCauseValue", HFILL }},
+        "camel.Cause", HFILL }},
     { &hf_camel_sendingSideID,
       { "sendingSideID", "camel.sendingSideID",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.LegType", HFILL }},
     { &hf_camel_forwardServiceInteractionInd,
       { "forwardServiceInteractionInd", "camel.forwardServiceInteractionInd",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ServiceInteractionIndicatorsTwo/forwardServiceInteractionInd", HFILL }},
+        "camel.ForwardServiceInteractionInd", HFILL }},
     { &hf_camel_backwardServiceInteractionInd,
       { "backwardServiceInteractionInd", "camel.backwardServiceInteractionInd",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ServiceInteractionIndicatorsTwo/backwardServiceInteractionInd", HFILL }},
+        "camel.BackwardServiceInteractionInd", HFILL }},
     { &hf_camel_bothwayThroughConnectionInd,
       { "bothwayThroughConnectionInd", "camel.bothwayThroughConnectionInd",
         FT_UINT32, BASE_DEC, VALS(camel_BothwayThroughConnectionInd_vals), 0,
-        "ServiceInteractionIndicatorsTwo/bothwayThroughConnectionInd", HFILL }},
+        "camel.BothwayThroughConnectionInd", HFILL }},
     { &hf_camel_connectedNumberTreatmentInd,
       { "connectedNumberTreatmentInd", "camel.connectedNumberTreatmentInd",
         FT_UINT32, BASE_DEC, VALS(camel_ConnectedNumberTreatmentInd_vals), 0,
-        "ServiceInteractionIndicatorsTwo/connectedNumberTreatmentInd", HFILL }},
+        "camel.ConnectedNumberTreatmentInd", HFILL }},
     { &hf_camel_nonCUGCall,
       { "nonCUGCall", "camel.nonCUGCall",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ServiceInteractionIndicatorsTwo/nonCUGCall", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_holdTreatmentIndicator,
       { "holdTreatmentIndicator", "camel.holdTreatmentIndicator",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "ServiceInteractionIndicatorsTwo/holdTreatmentIndicator", HFILL }},
+        "camel.OCTET_STRING_SIZE_1", HFILL }},
     { &hf_camel_cwTreatmentIndicator,
       { "cwTreatmentIndicator", "camel.cwTreatmentIndicator",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "ServiceInteractionIndicatorsTwo/cwTreatmentIndicator", HFILL }},
+        "camel.OCTET_STRING_SIZE_1", HFILL }},
     { &hf_camel_ectTreatmentIndicator,
       { "ectTreatmentIndicator", "camel.ectTreatmentIndicator",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "ServiceInteractionIndicatorsTwo/ectTreatmentIndicator", HFILL }},
+        "camel.OCTET_STRING_SIZE_1", HFILL }},
     { &hf_camel_eventTypeSMS,
       { "eventTypeSMS", "camel.eventTypeSMS",
         FT_UINT32, BASE_DEC, VALS(camel_EventTypeSMS_vals), 0,
-        "", HFILL }},
+        "camel.EventTypeSMS", HFILL }},
     { &hf_camel_timeSinceTariffSwitch,
       { "timeSinceTariffSwitch", "camel.timeSinceTariffSwitch",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "TimeIfTariffSwitch/timeSinceTariffSwitch", HFILL }},
+        "camel.INTEGER_0_864000", HFILL }},
     { &hf_camel_tttariffSwitchInterval,
       { "tttariffSwitchInterval", "camel.tttariffSwitchInterval",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "TimeIfTariffSwitch/tttariffSwitchInterval", HFILL }},
+        "camel.INTEGER_1_864000", HFILL }},
     { &hf_camel_timeIfNoTariffSwitch,
       { "timeIfNoTariffSwitch", "camel.timeIfNoTariffSwitch",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "TimeInformation/timeIfNoTariffSwitch", HFILL }},
+        "camel.TimeIfNoTariffSwitch", HFILL }},
     { &hf_camel_timeIfTariffSwitch,
       { "timeIfTariffSwitch", "camel.timeIfTariffSwitch",
         FT_NONE, BASE_NONE, NULL, 0,
-        "TimeInformation/timeIfTariffSwitch", HFILL }},
+        "camel.TimeIfTariffSwitch", HFILL }},
     { &hf_camel_toneID,
       { "toneID", "camel.toneID",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Tone/toneID", HFILL }},
+        "camel.Integer4", HFILL }},
     { &hf_camel_duration3,
       { "duration3", "camel.duration3",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Tone/duration3", HFILL }},
+        "camel.Integer4", HFILL }},
     { &hf_camel_volumeIfNoTariffSwitch,
       { "volumeIfNoTariffSwitch", "camel.volumeIfNoTariffSwitch",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "TransferredVolume/volumeIfNoTariffSwitch", HFILL }},
+        "camel.INTEGER_0_2147483647", HFILL }},
     { &hf_camel_volumeIfTariffSwitch,
       { "volumeIfTariffSwitch", "camel.volumeIfTariffSwitch",
         FT_NONE, BASE_NONE, NULL, 0,
-        "TransferredVolume/volumeIfTariffSwitch", HFILL }},
+        "camel.T_volumeIfTariffSwitch", HFILL }},
     { &hf_camel_volumeSinceLastTariffSwitch,
       { "volumeSinceLastTariffSwitch", "camel.volumeSinceLastTariffSwitch",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "TransferredVolume/volumeIfTariffSwitch/volumeSinceLastTariffSwitch", HFILL }},
+        "camel.INTEGER_0_2147483647", HFILL }},
     { &hf_camel_volumeTariffSwitchInterval,
       { "volumeTariffSwitchInterval", "camel.volumeTariffSwitchInterval",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "TransferredVolume/volumeIfTariffSwitch/volumeTariffSwitchInterval", HFILL }},
+        "camel.INTEGER_0_2147483647", HFILL }},
     { &hf_camel_rOVolumeIfNoTariffSwitch,
       { "rOVolumeIfNoTariffSwitch", "camel.rOVolumeIfNoTariffSwitch",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "TransferredVolumeRollOver/rOVolumeIfNoTariffSwitch", HFILL }},
+        "camel.INTEGER_0_255", HFILL }},
     { &hf_camel_rOVolumeIfTariffSwitch,
       { "rOVolumeIfTariffSwitch", "camel.rOVolumeIfTariffSwitch",
         FT_NONE, BASE_NONE, NULL, 0,
-        "TransferredVolumeRollOver/rOVolumeIfTariffSwitch", HFILL }},
+        "camel.T_rOVolumeIfTariffSwitch", HFILL }},
     { &hf_camel_rOVolumeSinceLastTariffSwitch,
       { "rOVolumeSinceLastTariffSwitch", "camel.rOVolumeSinceLastTariffSwitch",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "TransferredVolumeRollOver/rOVolumeIfTariffSwitch/rOVolumeSinceLastTariffSwitch", HFILL }},
+        "camel.INTEGER_0_255", HFILL }},
     { &hf_camel_rOVolumeTariffSwitchInterval,
       { "rOVolumeTariffSwitchInterval", "camel.rOVolumeTariffSwitchInterval",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "TransferredVolumeRollOver/rOVolumeIfTariffSwitch/rOVolumeTariffSwitchInterval", HFILL }},
+        "camel.INTEGER_0_255", HFILL }},
     { &hf_camel_integer,
       { "integer", "camel.integer",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "VariablePart/integer", HFILL }},
+        "camel.Integer4", HFILL }},
     { &hf_camel_number,
       { "number", "camel.number",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "VariablePart/number", HFILL }},
+        "camel.Digits", HFILL }},
     { &hf_camel_time,
       { "time", "camel.time",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "VariablePart/time", HFILL }},
+        "camel.OCTET_STRING_SIZE_2", HFILL }},
     { &hf_camel_date,
       { "date", "camel.date",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "VariablePart/date", HFILL }},
+        "camel.OCTET_STRING_SIZE_4", HFILL }},
     { &hf_camel_price,
       { "price", "camel.price",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "VariablePart/price", HFILL }},
+        "camel.OCTET_STRING_SIZE_4", HFILL }},
     { &hf_camel_pDPTypeOrganization1,
       { "pDPTypeOrganization", "camel.pDPTypeOrganization",
         FT_UINT8, BASE_DEC, VALS(gsm_map_PDP_Type_Organisation_vals), 0x0f,
-        "PDPType/pDPTypeOrganization", HFILL }},
+        "camel.PDPTypeOrganization", HFILL }},
     { &hf_camel_pDPTypeNumber1,
       { "pDPTypeNumber", "camel.pDPTypeNumber",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PDPType/pDPTypeNumber", HFILL }},
+        "camel.PDPTypeNumber", HFILL }},
     { &hf_camel_pDPAddress1,
       { "pDPAddress", "camel.pDPAddress",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PDPType/pDPAddress", HFILL }},
+        "camel.PDPAddress", HFILL }},
     { &hf_camel_local,
       { "local", "camel.local",
         FT_INT32, BASE_DEC, NULL, 0,
-        "Code/local", HFILL }},
+        "camel.INTEGER", HFILL }},
     { &hf_camel_global,
       { "global", "camel.global",
         FT_OID, BASE_NONE, NULL, 0,
-        "Code/global", HFILL }},
+        "camel.OBJECT_IDENTIFIER", HFILL }},
     { &hf_camel_messageType,
       { "messageType", "camel.messageType",
         FT_UINT32, BASE_DEC, VALS(camel_T_messageType_vals), 0,
-        "MiscCallInfo/messageType", HFILL }},
+        "camel.T_messageType", HFILL }},
     { &hf_camel_firstExtensionExtensionType,
       { "firstExtensionExtensionType", "camel.firstExtensionExtensionType",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SupportedExtensionsExtensionType/firstExtensionExtensionType", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_extId,
       { "extId", "camel.extId",
         FT_OID, BASE_NONE, NULL, 0,
-        "PrivateExtension/extId", HFILL }},
+        "camel.ExtensionSetextensionId", HFILL }},
     { &hf_camel_callresultOctet,
       { "callresultOctet", "camel.callresultOctet",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "ApplyChargingReportArg/callresultOctet", HFILL }},
+        "camel.CallresultoctetPDU", HFILL }},
     { &hf_camel_allRequests,
       { "allRequests", "camel.allRequests",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CancelArg/allRequests", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_callSegmentToCancel,
       { "callSegmentToCancel", "camel.callSegmentToCancel",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CancelArg/callSegmentToCancel", HFILL }},
+        "camel.CallSegmentToCancel", HFILL }},
     { &hf_camel_digitsResponse,
       { "digitsResponse", "camel.digitsResponse",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "ReceivedInformationArg/digitsResponse", HFILL }},
+        "camel.Digits", HFILL }},
     { &hf_camel_pdpID,
       { "pdpID", "camel.pdpID",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "ConnectGPRSArg/pdpID", HFILL }},
+        "camel.PDPId", HFILL }},
     { &hf_camel_gPRSCause,
       { "gPRSCause", "camel.gPRSCause",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "EntityReleasedGPRSArg/gPRSCause", HFILL }},
+        "camel.GPRSCause", HFILL }},
     { &hf_camel_gprsCause,
       { "gprsCause", "camel.gprsCause",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "ReleaseGPRSArg/gprsCause", HFILL }},
+        "camel.GPRSCause", HFILL }},
     { &hf_camel_gPRSEvent,
       { "gPRSEvent", "camel.gPRSEvent",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "RequestReportGPRSEventArg/gPRSEvent", HFILL }},
+        "camel.GPRSEventArray", HFILL }},
     { &hf_camel_GPRSEventArray_item,
       { "Item", "camel.GPRSEventArray_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "GPRSEventArray/_item", HFILL }},
+        "camel.GPRSEvent", HFILL }},
     { &hf_camel_sCIGPRSBillingChargingCharacteristics,
       { "sCIGPRSBillingChargingCharacteristics", "camel.sCIGPRSBillingChargingCharacteristics",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "SendChargingInformationGPRSArg/sCIGPRSBillingChargingCharacteristics", HFILL }},
+        "camel.SCIGPRSBillingChargingCharacteristics", HFILL }},
     { &hf_camel_assumedIdle,
       { "assumedIdle", "camel.assumedIdle",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SubscriberState/assumedIdle", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_camelBusy,
       { "camelBusy", "camel.camelBusy",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SubscriberState/camelBusy", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_netDetNotReachable,
       { "netDetNotReachable", "camel.netDetNotReachable",
         FT_UINT32, BASE_DEC, VALS(camel_NotReachableReason_vals), 0,
-        "SubscriberState/netDetNotReachable", HFILL }},
+        "camel.NotReachableReason", HFILL }},
     { &hf_camel_notProvidedFromVLR,
       { "notProvidedFromVLR", "camel.notProvidedFromVLR",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SubscriberState/notProvidedFromVLR", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_PrivateExtensionList_item,
       { "Item", "camel.PrivateExtensionList_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PrivateExtensionList/_item", HFILL }},
+        "camel.PrivateExtension", HFILL }},
     { &hf_camel_cellIdFixedLength,
       { "cellIdFixedLength", "camel.cellIdFixedLength",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "CellIdOrLAI/cellIdFixedLength", HFILL }},
+        "camel.CellIdFixedLength", HFILL }},
     { &hf_camel_laiFixedLength,
       { "laiFixedLength", "camel.laiFixedLength",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "CellIdOrLAI/laiFixedLength", HFILL }},
+        "gsm_map.LAIFixedLength", HFILL }},
     { &hf_camel_VariablePartsArray_item,
       { "Item", "camel.VariablePartsArray_item",
         FT_UINT32, BASE_DEC, VALS(camel_VariablePart_vals), 0,
-        "VariablePartsArray/_item", HFILL }},
+        "camel.VariablePart", HFILL }},
     { &hf_camel_gmscAddress,
       { "gmscAddress", "camel.gmscAddress",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "InitialDPArgExtension/gmscAddress", HFILL }},
+        "camel.ISDN_AddressString", HFILL }},
     { &hf_camel_ms_Classmark2,
       { "ms-Classmark2", "camel.ms_Classmark2",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "InitialDPArgExtension/ms-Classmark2", HFILL }},
+        "gsm_map.MS_Classmark2", HFILL }},
     { &hf_camel_iMEI,
       { "iMEI", "camel.iMEI",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "InitialDPArgExtension/iMEI", HFILL }},
+        "gsm_map.IMEI", HFILL }},
     { &hf_camel_supportedCamelPhases,
       { "supportedCamelPhases", "camel.supportedCamelPhases",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.SupportedCamelPhases", HFILL }},
     { &hf_camel_offeredCamel4Functionalities,
       { "offeredCamel4Functionalities", "camel.offeredCamel4Functionalities",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.OfferedCamel4Functionalities", HFILL }},
     { &hf_camel_bearerCapability2,
       { "bearerCapability2", "camel.bearerCapability2",
         FT_UINT32, BASE_DEC, VALS(camel_BearerCapability_vals), 0,
-        "InitialDPArgExtension/bearerCapability2", HFILL }},
+        "camel.BearerCapability", HFILL }},
     { &hf_camel_highLayerCompatibility2,
       { "highLayerCompatibility2", "camel.highLayerCompatibility2",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "InitialDPArgExtension/highLayerCompatibility2", HFILL }},
+        "camel.HighLayerCompatibility", HFILL }},
     { &hf_camel_lowLayerCompatibility,
       { "lowLayerCompatibility", "camel.lowLayerCompatibility",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "InitialDPArgExtension/lowLayerCompatibility", HFILL }},
+        "camel.LowLayerCompatibility", HFILL }},
     { &hf_camel_lowLayerCompatibility2,
       { "lowLayerCompatibility2", "camel.lowLayerCompatibility2",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "InitialDPArgExtension/lowLayerCompatibility2", HFILL }},
+        "camel.LowLayerCompatibility", HFILL }},
     { &hf_camel_enhancedDialledServicesAllowed,
       { "enhancedDialledServicesAllowed", "camel.enhancedDialledServicesAllowed",
         FT_NONE, BASE_NONE, NULL, 0,
-        "InitialDPArgExtension/enhancedDialledServicesAllowed", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_uu_Data,
       { "uu-Data", "camel.uu_Data",
         FT_NONE, BASE_NONE, NULL, 0,
-        "InitialDPArgExtension/uu-Data", HFILL }},
+        "gsm_map.UU_Data", HFILL }},
     { &hf_camel_destinationRoutingAddress,
       { "destinationRoutingAddress", "camel.destinationRoutingAddress",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "camel.DestinationRoutingAddress", HFILL }},
     { &hf_camel_legToBeCreated,
       { "legToBeCreated", "camel.legToBeCreated",
         FT_UINT32, BASE_DEC, VALS(camel_LegID_vals), 0,
-        "InitiateCallAttemptArg/legToBeCreated", HFILL }},
+        "camel.LegID", HFILL }},
     { &hf_camel_newCallSegment,
       { "newCallSegment", "camel.newCallSegment",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "camel.CallSegmentID", HFILL }},
     { &hf_camel_callingPartyNumber,
       { "callingPartyNumber", "camel.callingPartyNumber",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.CallingPartyNumber", HFILL }},
     { &hf_camel_callReferenceNumber,
       { "callReferenceNumber", "camel.callReferenceNumber",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.CallReferenceNumber", HFILL }},
     { &hf_camel_gsmSCFAddress,
       { "gsmSCFAddress", "camel.gsmSCFAddress",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "InitiateCallAttemptArg/gsmSCFAddress", HFILL }},
+        "camel.ISDN_AddressString", HFILL }},
     { &hf_camel_suppress_T_CSI,
       { "suppress-T-CSI", "camel.suppress_T_CSI",
         FT_NONE, BASE_NONE, NULL, 0,
-        "InitiateCallAttemptArg/suppress-T-CSI", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_legIDToMove,
       { "legIDToMove", "camel.legIDToMove",
         FT_UINT32, BASE_DEC, VALS(camel_LegID_vals), 0,
-        "MoveLegArg/legIDToMove", HFILL }},
+        "camel.LegID", HFILL }},
     { &hf_camel_legOrCallSegment,
       { "legOrCallSegment", "camel.legOrCallSegment",
         FT_UINT32, BASE_DEC, VALS(camel_LegOrCallSegment_vals), 0,
-        "", HFILL }},
+        "camel.LegOrCallSegment", HFILL }},
     { &hf_camel_miscGPRSInfo,
       { "miscGPRSInfo", "camel.miscGPRSInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventReportGPRSArg/miscGPRSInfo", HFILL }},
+        "camel.MiscCallInfo", HFILL }},
     { &hf_camel_gPRSEventSpecificInformation,
       { "gPRSEventSpecificInformation", "camel.gPRSEventSpecificInformation",
         FT_UINT32, BASE_DEC, VALS(camel_GPRSEventSpecificInformation_vals), 0,
-        "EventReportGPRSArg/gPRSEventSpecificInformation", HFILL }},
+        "camel.GPRSEventSpecificInformation", HFILL }},
     { &hf_camel_type,
       { "type", "camel.type",
         FT_UINT32, BASE_DEC, VALS(camel_Code_vals), 0,
-        "ExtensionField/type", HFILL }},
+        "camel.SupportedExtensionsid", HFILL }},
     { &hf_camel_criticality,
       { "criticality", "camel.criticality",
         FT_UINT32, BASE_DEC, VALS(camel_CriticalityType_vals), 0,
-        "ExtensionField/criticality", HFILL }},
+        "camel.CriticalityType", HFILL }},
     { &hf_camel_value,
       { "value", "camel.value",
         FT_UINT32, BASE_DEC, VALS(camel_SupportedExtensionsExtensionType_vals), 0,
-        "ExtensionField/value", HFILL }},
+        "camel.SupportedExtensionsExtensionType", HFILL }},
     { &hf_camel_aChBillingChargingCharacteristics,
       { "aChBillingChargingCharacteristics", "camel.aChBillingChargingCharacteristics",
         FT_UINT32, BASE_DEC, VALS(camel_AChBillingChargingCharacteristics_vals), 0,
-        "ApplyChargingArg/aChBillingChargingCharacteristics", HFILL }},
+        "camel.AChBillingChargingCharacteristics", HFILL }},
     { &hf_camel_partyToCharge1,
       { "partyToCharge1", "camel.partyToCharge1",
         FT_UINT32, BASE_DEC, VALS(camel_SendingSideID_vals), 0,
-        "ApplyChargingArg/partyToCharge1", HFILL }},
+        "camel.SendingSideID", HFILL }},
     { &hf_camel_ExtensionsArray_item,
       { "Item", "camel.ExtensionsArray_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ExtensionsArray/_item", HFILL }},
+        "camel.ExtensionField", HFILL }},
     { &hf_camel_correlationID,
       { "correlationID", "camel.correlationID",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.CorrelationID", HFILL }},
     { &hf_camel_iPSSPCapabilities,
       { "iPSSPCapabilities", "camel.iPSSPCapabilities",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.IPSSPCapabilities", HFILL }},
     { &hf_camel_requestedInformationTypeList,
       { "requestedInformationTypeList", "camel.requestedInformationTypeList",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CallInformationRequestArg/requestedInformationTypeList", HFILL }},
+        "camel.RequestedInformationTypeList", HFILL }},
     { &hf_camel_legID3,
       { "legID3", "camel.legID3",
         FT_UINT32, BASE_DEC, VALS(camel_SendingSideID_vals), 0,
-        "CallInformationRequestArg/legID3", HFILL }},
+        "camel.SendingSideID", HFILL }},
     { &hf_camel_alertingPattern,
       { "alertingPattern", "camel.alertingPattern",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.AlertingPattern", HFILL }},
     { &hf_camel_originalCalledPartyID,
       { "originalCalledPartyID", "camel.originalCalledPartyID",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.OriginalCalledPartyID", HFILL }},
     { &hf_camel_carrier,
       { "carrier", "camel.carrier",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.Carrier", HFILL }},
     { &hf_camel_callingPartysCategory,
       { "callingPartysCategory", "camel.callingPartysCategory",
         FT_UINT16, BASE_DEC, VALS(isup_calling_partys_category_value), 0,
-        "", HFILL }},
+        "camel.CallingPartysCategory", HFILL }},
     { &hf_camel_redirectingPartyID,
       { "redirectingPartyID", "camel.redirectingPartyID",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.RedirectingPartyID", HFILL }},
     { &hf_camel_redirectionInformation,
       { "redirectionInformation", "camel.redirectionInformation",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.RedirectionInformation", HFILL }},
     { &hf_camel_genericNumbers,
       { "genericNumbers", "camel.genericNumbers",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "camel.GenericNumbers", HFILL }},
     { &hf_camel_serviceInteractionIndicatorsTwo,
       { "serviceInteractionIndicatorsTwo", "camel.serviceInteractionIndicatorsTwo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "camel.ServiceInteractionIndicatorsTwo", HFILL }},
     { &hf_camel_chargeNumber,
       { "chargeNumber", "camel.chargeNumber",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.ChargeNumber", HFILL }},
     { &hf_camel_cug_Interlock,
       { "cug-Interlock", "camel.cug_Interlock",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.CUG_Interlock", HFILL }},
     { &hf_camel_cug_OutgoingAccess,
       { "cug-OutgoingAccess", "camel.cug_OutgoingAccess",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_suppressionOfAnnouncement,
       { "suppressionOfAnnouncement", "camel.suppressionOfAnnouncement",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "camel.SuppressionOfAnnouncement", HFILL }},
     { &hf_camel_oCSIApplicable,
       { "oCSIApplicable", "camel.oCSIApplicable",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ConnectArg/oCSIApplicable", HFILL }},
+        "camel.OCSIApplicable", HFILL }},
     { &hf_camel_naOliInfo,
       { "naOliInfo", "camel.naOliInfo",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.NAOliInfo", HFILL }},
     { &hf_camel_bor_InterrogationRequested,
       { "bor-InterrogationRequested", "camel.bor_InterrogationRequested",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_resourceAddress,
       { "resourceAddress", "camel.resourceAddress",
         FT_UINT32, BASE_DEC, VALS(camel_T_resourceAddress_vals), 0,
-        "ConnectToResourceArg/resourceAddress", HFILL }},
+        "camel.T_resourceAddress", HFILL }},
     { &hf_camel_ipRoutingAddress,
       { "ipRoutingAddress", "camel.ipRoutingAddress",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "ConnectToResourceArg/resourceAddress/ipRoutingAddress", HFILL }},
+        "camel.IPRoutingAddress", HFILL }},
     { &hf_camel_none,
       { "none", "camel.none",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ConnectToResourceArg/resourceAddress/none", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_suppress_O_CSI,
       { "suppress-O-CSI", "camel.suppress_O_CSI",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ContinueWithArgumentArg/suppress-O-CSI", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_continueWithArgumentArgExtension,
       { "continueWithArgumentArgExtension", "camel.continueWithArgumentArgExtension",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ContinueWithArgumentArg/continueWithArgumentArgExtension", HFILL }},
+        "camel.ContinueWithArgumentArgExtension", HFILL }},
     { &hf_camel_suppress_D_CSI,
       { "suppress-D-CSI", "camel.suppress_D_CSI",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ContinueWithArgumentArgExtension/suppress-D-CSI", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_suppress_N_CSI,
       { "suppress-N-CSI", "camel.suppress_N_CSI",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ContinueWithArgumentArgExtension/suppress-N-CSI", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_suppressOutgoingCallBarring,
       { "suppressOutgoingCallBarring", "camel.suppressOutgoingCallBarring",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ContinueWithArgumentArgExtension/suppressOutgoingCallBarring", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_legToBeReleased,
       { "legToBeReleased", "camel.legToBeReleased",
         FT_UINT32, BASE_DEC, VALS(camel_LegID_vals), 0,
-        "DisconnectLegArg/legToBeReleased", HFILL }},
+        "camel.LegID", HFILL }},
     { &hf_camel_callSegmentFailure,
       { "callSegmentFailure", "camel.callSegmentFailure",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EntityReleasedArg/callSegmentFailure", HFILL }},
+        "camel.CallSegmentFailure", HFILL }},
     { &hf_camel_bCSM_Failure,
       { "bCSM-Failure", "camel.bCSM_Failure",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EntityReleasedArg/bCSM-Failure", HFILL }},
+        "camel.BCSM_Failure", HFILL }},
     { &hf_camel_assistingSSPIPRoutingAddress,
       { "assistingSSPIPRoutingAddress", "camel.assistingSSPIPRoutingAddress",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "EstablishTemporaryConnectionArg/assistingSSPIPRoutingAddress", HFILL }},
+        "camel.AssistingSSPIPRoutingAddress", HFILL }},
     { &hf_camel_eventSpecificInformationBCSM,
       { "eventSpecificInformationBCSM", "camel.eventSpecificInformationBCSM",
         FT_UINT32, BASE_DEC, VALS(camel_EventSpecificInformationBCSM_vals), 0,
-        "EventReportBCSMArg/eventSpecificInformationBCSM", HFILL }},
+        "camel.EventSpecificInformationBCSM", HFILL }},
     { &hf_camel_legID4,
       { "legID4", "camel.legID4",
         FT_UINT32, BASE_DEC, VALS(camel_ReceivingSideID_vals), 0,
-        "EventReportBCSMArg/legID4", HFILL }},
+        "camel.ReceivingSideID", HFILL }},
     { &hf_camel_miscCallInfo,
       { "miscCallInfo", "camel.miscCallInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "camel.MiscCallInfo", HFILL }},
     { &hf_camel_timerID,
       { "timerID", "camel.timerID",
         FT_UINT32, BASE_DEC, VALS(camel_TimerID_vals), 0,
-        "", HFILL }},
+        "camel.TimerID", HFILL }},
     { &hf_camel_timervalue,
       { "timervalue", "camel.timervalue",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "camel.TimerValue", HFILL }},
     { &hf_camel_sCIBillingChargingCharacteristics,
       { "sCIBillingChargingCharacteristics", "camel.sCIBillingChargingCharacteristics",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "SendChargingInformationArg/sCIBillingChargingCharacteristics", HFILL }},
+        "camel.SCIBillingChargingCharacteristics", HFILL }},
     { &hf_camel_partyToCharge2,
       { "partyToCharge2", "camel.partyToCharge2",
         FT_UINT32, BASE_DEC, VALS(camel_SendingSideID_vals), 0,
-        "SendChargingInformationArg/partyToCharge2", HFILL }},
+        "camel.SendingSideID", HFILL }},
     { &hf_camel_legToBeSplit,
       { "legToBeSplit", "camel.legToBeSplit",
         FT_UINT32, BASE_DEC, VALS(camel_LegID_vals), 0,
-        "SplitLegArg/legToBeSplit", HFILL }},
+        "camel.LegID", HFILL }},
     { &hf_camel_destinationReference,
       { "destinationReference", "camel.destinationReference",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CAPGPRSReferenceNumber/destinationReference", HFILL }},
+        "camel.Integer4", HFILL }},
     { &hf_camel_originationReference,
       { "originationReference", "camel.originationReference",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CAPGPRSReferenceNumber/originationReference", HFILL }},
+        "camel.Integer4", HFILL }},
     { &hf_camel_eventSpecificInformationSMS,
       { "eventSpecificInformationSMS", "camel.eventSpecificInformationSMS",
         FT_UINT32, BASE_DEC, VALS(camel_EventSpecificInformationSMS_vals), 0,
-        "EventReportSMSArg/eventSpecificInformationSMS", HFILL }},
+        "camel.EventSpecificInformationSMS", HFILL }},
     { &hf_camel_sMSEvents,
       { "sMSEvents", "camel.sMSEvents",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "RequestReportSMSEventArg/sMSEvents", HFILL }},
+        "camel.SMSEventArray", HFILL }},
     { &hf_camel_SMSEventArray_item,
       { "Item", "camel.SMSEventArray_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SMSEventArray/_item", HFILL }},
+        "camel.SMSEvent", HFILL }},
     { &hf_camel_bcsmEvents,
       { "bcsmEvents", "camel.bcsmEvents",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "RequestReportBCSMEventArg/bcsmEvents", HFILL }},
+        "camel.BCSMEventArray", HFILL }},
     { &hf_camel_BCSMEventArray_item,
       { "Item", "camel.BCSMEventArray_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "BCSMEventArray/_item", HFILL }},
+        "camel.BCSMEvent", HFILL }},
     { &hf_camel_callingPartysNumber,
       { "callingPartysNumber", "camel.callingPartysNumber",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "ConnectSMSArg/callingPartysNumber", HFILL }},
+        "camel.ISDN_AddressString", HFILL }},
     { &hf_camel_destinationSubscriberNumber,
       { "destinationSubscriberNumber", "camel.destinationSubscriberNumber",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.CalledPartyBCDNumber", HFILL }},
     { &hf_camel_sMSCAddress,
       { "sMSCAddress", "camel.sMSCAddress",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.ISDN_AddressString", HFILL }},
     { &hf_camel_requestedInformationList,
       { "requestedInformationList", "camel.requestedInformationList",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CallInformationReportArg/requestedInformationList", HFILL }},
+        "camel.RequestedInformationList", HFILL }},
     { &hf_camel_legID5,
       { "legID5", "camel.legID5",
         FT_UINT32, BASE_DEC, VALS(camel_ReceivingSideID_vals), 0,
-        "CallInformationReportArg/legID5", HFILL }},
+        "camel.ReceivingSideID", HFILL }},
     { &hf_camel_disconnectFromIPForbidden,
       { "disconnectFromIPForbidden", "camel.disconnectFromIPForbidden",
         FT_BOOLEAN, 8, NULL, 0,
-        "", HFILL }},
+        "camel.BOOLEAN", HFILL }},
     { &hf_camel_requestAnnouncementComplete,
       { "requestAnnouncementComplete", "camel.requestAnnouncementComplete",
         FT_BOOLEAN, 8, NULL, 0,
-        "PlayAnnouncementArg/requestAnnouncementComplete", HFILL }},
+        "camel.BOOLEAN", HFILL }},
     { &hf_camel_collectedInfo,
       { "collectedInfo", "camel.collectedInfo",
         FT_UINT32, BASE_DEC, VALS(camel_CollectedInfo_vals), 0,
-        "PromptAndCollectUserInformationArg/collectedInfo", HFILL }},
+        "camel.CollectedInfo", HFILL }},
     { &hf_camel_mSISDN,
       { "mSISDN", "camel.mSISDN",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "InitialDPGPRSArg/mSISDN", HFILL }},
+        "camel.ISDN_AddressString", HFILL }},
     { &hf_camel_iMSI,
       { "iMSI", "camel.iMSI",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "gsm_map.IMSI", HFILL }},
     { &hf_camel_gPRSMSClass,
       { "gPRSMSClass", "camel.gPRSMSClass",
         FT_NONE, BASE_NONE, NULL, 0,
-        "InitialDPGPRSArg/gPRSMSClass", HFILL }},
+        "camel.GPRSMSClass", HFILL }},
     { &hf_camel_sGSNCapabilities,
       { "sGSNCapabilities", "camel.sGSNCapabilities",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "InitialDPGPRSArg/sGSNCapabilities", HFILL }},
+        "camel.SGSNCapabilities", HFILL }},
     { &hf_camel_gapCriteria,
       { "gapCriteria", "camel.gapCriteria",
         FT_UINT32, BASE_DEC, VALS(camel_GapCriteria_vals), 0,
-        "CallGapArg/gapCriteria", HFILL }},
+        "camel.GapCriteria", HFILL }},
     { &hf_camel_gapIndicators,
       { "gapIndicators", "camel.gapIndicators",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CallGapArg/gapIndicators", HFILL }},
+        "camel.GapIndicators", HFILL }},
     { &hf_camel_controlType,
       { "controlType", "camel.controlType",
         FT_UINT32, BASE_DEC, VALS(camel_ControlType_vals), 0,
-        "CallGapArg/controlType", HFILL }},
+        "camel.ControlType", HFILL }},
     { &hf_camel_gapTreatment,
       { "gapTreatment", "camel.gapTreatment",
         FT_UINT32, BASE_DEC, VALS(camel_GapTreatment_vals), 0,
-        "CallGapArg/gapTreatment", HFILL }},
+        "camel.GapTreatment", HFILL }},
     { &hf_camel_calledPartyNumber,
       { "calledPartyNumber", "camel.calledPartyNumber",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "InitialDPArg/calledPartyNumber", HFILL }},
+        "camel.CalledPartyNumber", HFILL }},
     { &hf_camel_cGEncountered,
       { "cGEncountered", "camel.cGEncountered",
         FT_UINT32, BASE_DEC, VALS(camel_CGEncountered_vals), 0,
-        "InitialDPArg/cGEncountered", HFILL }},
+        "camel.CGEncountered", HFILL }},
     { &hf_camel_locationNumber,
       { "locationNumber", "camel.locationNumber",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "InitialDPArg/locationNumber", HFILL }},
+        "camel.LocationNumber", HFILL }},
     { &hf_camel_highLayerCompatibility,
       { "highLayerCompatibility", "camel.highLayerCompatibility",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "InitialDPArg/highLayerCompatibility", HFILL }},
+        "camel.HighLayerCompatibility", HFILL }},
     { &hf_camel_additionalCallingPartyNumber,
       { "additionalCallingPartyNumber", "camel.additionalCallingPartyNumber",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "InitialDPArg/additionalCallingPartyNumber", HFILL }},
+        "camel.AdditionalCallingPartyNumber", HFILL }},
     { &hf_camel_bearerCapability,
       { "bearerCapability", "camel.bearerCapability",
         FT_UINT32, BASE_DEC, VALS(camel_BearerCapability_vals), 0,
-        "InitialDPArg/bearerCapability", HFILL }},
+        "camel.BearerCapability", HFILL }},
     { &hf_camel_cug_Index,
       { "cug-Index", "camel.cug_Index",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "InitialDPArg/cug-Index", HFILL }},
+        "camel.CUG_Index", HFILL }},
     { &hf_camel_subscriberState,
       { "subscriberState", "camel.subscriberState",
         FT_UINT32, BASE_DEC, VALS(gsm_map_SubscriberState_vals), 0,
-        "InitialDPArg/subscriberState", HFILL }},
+        "camel.SubscriberState", HFILL }},
     { &hf_camel_mscAddress,
       { "mscAddress", "camel.mscAddress",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.ISDN_AddressString", HFILL }},
     { &hf_camel_calledPartyBCDNumber,
       { "calledPartyBCDNumber", "camel.calledPartyBCDNumber",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "InitialDPArg/calledPartyBCDNumber", HFILL }},
+        "camel.CalledPartyBCDNumber", HFILL }},
     { &hf_camel_timeAndTimezone,
       { "timeAndTimezone", "camel.timeAndTimezone",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "camel.TimeAndTimezone", HFILL }},
     { &hf_camel_gsm_ForwardingPending,
       { "gsm-ForwardingPending", "camel.gsm_ForwardingPending",
         FT_NONE, BASE_NONE, NULL, 0,
-        "InitialDPArg/gsm-ForwardingPending", HFILL }},
+        "camel.NULL", HFILL }},
     { &hf_camel_initialDPArgExtension,
       { "initialDPArgExtension", "camel.initialDPArgExtension",
         FT_NONE, BASE_NONE, NULL, 0,
-        "InitialDPArg/initialDPArgExtension", HFILL }},
+        "camel.InitialDPArgExtension", HFILL }},
     { &hf_camel_callingPartyNumberas,
       { "callingPartyNumberas", "camel.callingPartyNumberas",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "InitialDPSMSArg/callingPartyNumberas", HFILL }},
+        "camel.ISDN_AddressString", HFILL }},
     { &hf_camel_locationInformationMSC,
       { "locationInformationMSC", "camel.locationInformationMSC",
         FT_NONE, BASE_NONE, NULL, 0,
-        "InitialDPSMSArg/locationInformationMSC", HFILL }},
+        "gsm_map.LocationInformation", HFILL }},
     { &hf_camel_tPShortMessageSubmissionSpecificInfo,
       { "tPShortMessageSubmissionSpecificInfo", "camel.tPShortMessageSubmissionSpecificInfo",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "InitialDPSMSArg/tPShortMessageSubmissionSpecificInfo", HFILL }},
+        "camel.TPShortMessageSubmissionInfo", HFILL }},
     { &hf_camel_tPProtocolIdentifier,
       { "tPProtocolIdentifier", "camel.tPProtocolIdentifier",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "InitialDPSMSArg/tPProtocolIdentifier", HFILL }},
+        "camel.TPProtocolIdentifier", HFILL }},
     { &hf_camel_tPDataCodingScheme,
       { "tPDataCodingScheme", "camel.tPDataCodingScheme",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "InitialDPSMSArg/tPDataCodingScheme", HFILL }},
+        "camel.TPDataCodingScheme", HFILL }},
     { &hf_camel_tPValidityPeriod,
       { "tPValidityPeriod", "camel.tPValidityPeriod",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "InitialDPSMSArg/tPValidityPeriod", HFILL }},
+        "camel.TPValidityPeriod", HFILL }},
     { &hf_camel_smsReferenceNumber,
       { "smsReferenceNumber", "camel.smsReferenceNumber",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "InitialDPSMSArg/smsReferenceNumber", HFILL }},
+        "camel.CallReferenceNumber", HFILL }},
     { &hf_camel_sgsnNumber,
       { "sgsnNumber", "camel.sgsnNumber",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "InitialDPSMSArg/sgsnNumber", HFILL }},
+        "camel.ISDN_AddressString", HFILL }},
     { &hf_camel_privateExtensionList,
       { "privateExtensionList", "camel.privateExtensionList",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ExtensionContainer/privateExtensionList", HFILL }},
+        "camel.PrivateExtensionList", HFILL }},
     { &hf_camel_pcs_Extensions,
       { "pcs-Extensions", "camel.pcs_Extensions",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ExtensionContainer/pcs-Extensions", HFILL }},
+        "camel.PCS_Extensions", HFILL }},
     { &hf_camel_chargingCharacteristics,
       { "chargingCharacteristics", "camel.chargingCharacteristics",
         FT_UINT32, BASE_DEC, VALS(camel_ChargingCharacteristics_vals), 0,
-        "ApplyChargingGPRSArg/chargingCharacteristics", HFILL }},
+        "camel.ChargingCharacteristics", HFILL }},
     { &hf_camel_chargingResult,
       { "chargingResult", "camel.chargingResult",
         FT_UINT32, BASE_DEC, VALS(camel_ChargingResult_vals), 0,
-        "ApplyChargingReportGPRSArg/chargingResult", HFILL }},
+        "camel.ChargingResult", HFILL }},
     { &hf_camel_active,
       { "active", "camel.active",
         FT_BOOLEAN, 8, NULL, 0,
-        "ApplyChargingReportGPRSArg/active", HFILL }},
+        "camel.BOOLEAN", HFILL }},
     { &hf_camel_chargingRollOver,
       { "chargingRollOver", "camel.chargingRollOver",
         FT_UINT32, BASE_DEC, VALS(camel_ChargingRollOver_vals), 0,
-        "ApplyChargingReportGPRSArg/chargingRollOver", HFILL }},
+        "camel.ChargingRollOver", HFILL }},
     { &hf_camel_problem,
       { "problem", "camel.problem",
         FT_UINT32, BASE_DEC, VALS(camel_T_problem_vals), 0,
-        "CancelFailedPARAM/problem", HFILL }},
+        "camel.T_problem", HFILL }},
     { &hf_camel_operation,
       { "operation", "camel.operation",
         FT_INT32, BASE_DEC, NULL, 0,
-        "CancelFailedPARAM/operation", HFILL }},
+        "camel.InvokeID", HFILL }},
     { &hf_camel_SupportedCamelPhases_phase1,
       { "phase1", "camel.phase1",
         FT_BOOLEAN, 8, NULL, 0x80,
index 2ec8a606276c3ee1cb6dc8f394c4c1519fa2cead..2812e0ee6b0546b589a6233ddcfffab74393f8e8 100644 (file)
@@ -1,6 +1,6 @@
 /* Do not modify this file.                                                   */
 /* It is created automatically by the ASN.1 to Wireshark dissector compiler   */
-/* ./packet-cdt.c                                                             */
+/* .\packet-cdt.c                                                             */
 /* ../../tools/asn2wrs.py -b -e -p cdt -c cdt.cnf -s packet-cdt-template cdt.asn */
 
 /* Input file: packet-cdt-template.c */
@@ -364,39 +364,39 @@ void proto_register_cdt (void) {
     { &hf_cdt_CompressedData_PDU,
       { "CompressedData", "cdt.CompressedData",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CompressedData", HFILL }},
+        "cdt.CompressedData", HFILL }},
     { &hf_cdt_compressionAlgorithm,
       { "compressionAlgorithm", "cdt.compressionAlgorithm",
         FT_UINT32, BASE_DEC, VALS(cdt_CompressionAlgorithmIdentifier_vals), 0,
-        "CompressedData/compressionAlgorithm", HFILL }},
+        "cdt.CompressionAlgorithmIdentifier", HFILL }},
     { &hf_cdt_compressedContentInfo,
       { "compressedContentInfo", "cdt.compressedContentInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CompressedData/compressedContentInfo", HFILL }},
+        "cdt.CompressedContentInfo", HFILL }},
     { &hf_cdt_algorithmID_ShortForm,
       { "algorithmID-ShortForm", "cdt.algorithmID_ShortForm",
         FT_INT32, BASE_DEC, VALS(cdt_AlgorithmID_ShortForm_vals), 0,
-        "CompressionAlgorithmIdentifier/algorithmID-ShortForm", HFILL }},
+        "cdt.AlgorithmID_ShortForm", HFILL }},
     { &hf_cdt_algorithmID_OID,
       { "algorithmID-OID", "cdt.algorithmID_OID",
         FT_OID, BASE_NONE, NULL, 0,
-        "CompressionAlgorithmIdentifier/algorithmID-OID", HFILL }},
+        "cdt.OBJECT_IDENTIFIER", HFILL }},
     { &hf_cdt_contentType,
       { "contentType", "cdt.contentType",
         FT_UINT32, BASE_DEC, VALS(cdt_T_contentType_vals), 0,
-        "CompressedContentInfo/contentType", HFILL }},
+        "cdt.T_contentType", HFILL }},
     { &hf_cdt_contentType_ShortForm,
       { "contentType-ShortForm", "cdt.contentType_ShortForm",
         FT_INT32, BASE_DEC, VALS(cdt_ContentType_ShortForm_vals), 0,
-        "CompressedContentInfo/contentType/contentType-ShortForm", HFILL }},
+        "cdt.ContentType_ShortForm", HFILL }},
     { &hf_cdt_contentType_OID,
       { "contentType-OID", "cdt.contentType_OID",
         FT_OID, BASE_NONE, NULL, 0,
-        "CompressedContentInfo/contentType/contentType-OID", HFILL }},
+        "cdt.OBJECT_IDENTIFIER", HFILL }},
     { &hf_cdt_compressedContent,
       { "compressedContent", "cdt.compressedContent",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "CompressedContentInfo/compressedContent", HFILL }},
+        "cdt.CompressedContent", HFILL }},
 
 /*--- End of included file: packet-cdt-hfarr.c ---*/
 #line 89 "packet-cdt-template.c"
index 6833dff64d93fa354b59b97593c2c72d21890199..ba79b39c22a9b2caaaaecf04922131036a89b0be 100644 (file)
@@ -1,6 +1,6 @@
 /* Do not modify this file.                                                   */
 /* It is created automatically by the ASN.1 to Wireshark dissector compiler   */
-/* ./packet-cdt.h                                                             */
+/* .\packet-cdt.h                                                             */
 /* ../../tools/asn2wrs.py -b -e -p cdt -c cdt.cnf -s packet-cdt-template cdt.asn */
 
 /* Input file: packet-cdt-template.h */
index f5038b3097d68d20cf44669c86f66e3cdf23d547..f2db1c617384e765adc08cfe99c448a7990fcdd1 100644 (file)
@@ -2984,535 +2984,535 @@ void proto_register_cmip(void) {
     { &hf_cmip_modifyOperator,
       { "modifyOperator", "cmip.modifyOperator",
         FT_INT32, BASE_DEC, VALS(cmip_ModifyOperator_vals), 0,
-        "", HFILL }},
+        "cmip.ModifyOperator", HFILL }},
     { &hf_cmip_attributeId,
       { "attributeId", "cmip.attributeId",
         FT_OID, BASE_NONE, NULL, 0,
-        "ModificationItem/attributeId", HFILL }},
+        "cmip.T_attributeId", HFILL }},
     { &hf_cmip_attributeValue,
       { "attributeValue", "cmip.attributeValue",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModificationItem/attributeValue", HFILL }},
+        "cmip.T_attributeValue", HFILL }},
     { &hf_cmip_managedObjectClass,
       { "managedObjectClass", "cmip.managedObjectClass",
         FT_UINT32, BASE_DEC, VALS(cmip_ObjectClass_vals), 0,
-        "", HFILL }},
+        "cmip.ObjectClass", HFILL }},
     { &hf_cmip_managedObjectInstance,
       { "managedObjectInstance", "cmip.managedObjectInstance",
         FT_UINT32, BASE_DEC, VALS(cmip_ObjectInstance_vals), 0,
-        "", HFILL }},
+        "cmip.ObjectInstance", HFILL }},
     { &hf_cmip_currentTime,
       { "currentTime", "cmip.currentTime",
         FT_STRING, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "cmip.GeneralizedTime", HFILL }},
     { &hf_cmip_getInfoList,
       { "getInfoList", "cmip.getInfoList",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "GetListError/getInfoList", HFILL }},
+        "cmip.SET_OF_GetInfoStatus", HFILL }},
     { &hf_cmip_getInfoList_item,
       { "Item", "cmip.getInfoList_item",
         FT_UINT32, BASE_DEC, VALS(cmip_GetInfoStatus_vals), 0,
-        "GetListError/getInfoList/_item", HFILL }},
+        "cmip.GetInfoStatus", HFILL }},
     { &hf_cmip_attributeIdError,
       { "attributeIdError", "cmip.attributeIdError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "GetInfoStatus/attributeIdError", HFILL }},
+        "cmip.AttributeIdError", HFILL }},
     { &hf_cmip_attribute,
       { "attribute", "cmip.attribute",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "cmip.Attribute", HFILL }},
     { &hf_cmip_errorStatus,
       { "errorStatus", "cmip.errorStatus",
         FT_UINT32, BASE_DEC, VALS(cmip_T_errorStatus_vals), 0,
-        "AttributeIdError/errorStatus", HFILL }},
+        "cmip.T_errorStatus", HFILL }},
     { &hf_cmip_attributeId1,
       { "attributeId", "cmip.attributeId",
         FT_UINT32, BASE_DEC, VALS(cmip_AttributeId_vals), 0,
-        "AttributeIdError/attributeId", HFILL }},
+        "cmip.AttributeId", HFILL }},
     { &hf_cmip_setInfoList,
       { "setInfoList", "cmip.setInfoList",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "SetListError/setInfoList", HFILL }},
+        "cmip.SET_OF_SetInfoStatus", HFILL }},
     { &hf_cmip_setInfoList_item,
       { "Item", "cmip.setInfoList_item",
         FT_UINT32, BASE_DEC, VALS(cmip_SetInfoStatus_vals), 0,
-        "SetListError/setInfoList/_item", HFILL }},
+        "cmip.SetInfoStatus", HFILL }},
     { &hf_cmip_actionErrorInfo,
       { "actionErrorInfo", "cmip.actionErrorInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ActionError/actionErrorInfo", HFILL }},
+        "cmip.ActionErrorInfo", HFILL }},
     { &hf_cmip_specificErrorInfo,
       { "specificErrorInfo", "cmip.specificErrorInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ProcessingFailure/specificErrorInfo", HFILL }},
+        "cmip.SpecificErrorInfo", HFILL }},
     { &hf_cmip_RDNSequence_item,
       { "Item", "cmip.RDNSequence_item",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "RDNSequence/_item", HFILL }},
+        "cmip.RelativeDistinguishedName", HFILL }},
     { &hf_cmip_RelativeDistinguishedName_item,
       { "Item", "cmip.RelativeDistinguishedName_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RelativeDistinguishedName/_item", HFILL }},
+        "cmip.AttributeValueAssertion", HFILL }},
     { &hf_cmip_deleteErrorInfo,
       { "deleteErrorInfo", "cmip.deleteErrorInfo",
         FT_UINT32, BASE_DEC, VALS(cmip_T_deleteErrorInfo_vals), 0,
-        "DeleteError/deleteErrorInfo", HFILL }},
+        "cmip.T_deleteErrorInfo", HFILL }},
     { &hf_cmip_attributeError,
       { "attributeError", "cmip.attributeError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SetInfoStatus/attributeError", HFILL }},
+        "cmip.AttributeError", HFILL }},
     { &hf_cmip_errorId,
       { "errorId", "cmip.errorId",
         FT_OID, BASE_NONE, NULL, 0,
-        "SpecificErrorInfo/errorId", HFILL }},
+        "cmip.T_errorId", HFILL }},
     { &hf_cmip_errorInfo,
       { "errorInfo", "cmip.errorInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SpecificErrorInfo/errorInfo", HFILL }},
+        "cmip.T_errorInfo", HFILL }},
     { &hf_cmip_actionType,
       { "actionType", "cmip.actionType",
         FT_OID, BASE_NONE, NULL, 0,
-        "NoSuchArgumentAction/actionType", HFILL }},
+        "cmip.T_actionType", HFILL }},
     { &hf_cmip_eventType,
       { "eventType", "cmip.eventType",
         FT_OID, BASE_NONE, NULL, 0,
-        "NoSuchArgumentEvent/eventType", HFILL }},
+        "cmip.T_eventType", HFILL }},
     { &hf_cmip_actionId,
       { "actionId", "cmip.actionId",
         FT_NONE, BASE_NONE, NULL, 0,
-        "NoSuchArgument/actionId", HFILL }},
+        "cmip.NoSuchArgumentAction", HFILL }},
     { &hf_cmip_eventId,
       { "eventId", "cmip.eventId",
         FT_NONE, BASE_NONE, NULL, 0,
-        "NoSuchArgument/eventId", HFILL }},
+        "cmip.NoSuchArgumentEvent", HFILL }},
     { &hf_cmip_eventType1,
       { "eventType", "cmip.eventType",
         FT_OID, BASE_NONE, NULL, 0,
-        "InvalidArgumentValueEventValue/eventType", HFILL }},
+        "cmip.T_eventType1", HFILL }},
     { &hf_cmip_eventInfo,
       { "eventInfo", "cmip.eventInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "InvalidArgumentValueEventValue/eventInfo", HFILL }},
+        "cmip.T_eventInfo", HFILL }},
     { &hf_cmip_actionValue,
       { "actionValue", "cmip.actionValue",
         FT_NONE, BASE_NONE, NULL, 0,
-        "InvalidArgumentValue/actionValue", HFILL }},
+        "cmip.ActionInfo", HFILL }},
     { &hf_cmip_eventValue,
       { "eventValue", "cmip.eventValue",
         FT_NONE, BASE_NONE, NULL, 0,
-        "InvalidArgumentValue/eventValue", HFILL }},
+        "cmip.InvalidArgumentValueEventValue", HFILL }},
     { &hf_cmip_actionType1,
       { "actionType", "cmip.actionType",
         FT_OID, BASE_NONE, NULL, 0,
-        "ErrorInfo/actionType", HFILL }},
+        "cmip.T_actionType1", HFILL }},
     { &hf_cmip_actionArgument,
       { "actionArgument", "cmip.actionArgument",
         FT_UINT32, BASE_DEC, VALS(cmip_NoSuchArgument_vals), 0,
-        "ErrorInfo/actionArgument", HFILL }},
+        "cmip.NoSuchArgument", HFILL }},
     { &hf_cmip_argumentValue,
       { "argumentValue", "cmip.argumentValue",
         FT_UINT32, BASE_DEC, VALS(cmip_InvalidArgumentValue_vals), 0,
-        "ErrorInfo/argumentValue", HFILL }},
+        "cmip.InvalidArgumentValue", HFILL }},
     { &hf_cmip_errorStatus1,
       { "errorStatus", "cmip.errorStatus",
         FT_UINT32, BASE_DEC, VALS(cmip_T_errorStatus1_vals), 0,
-        "ActionErrorInfo/errorStatus", HFILL }},
+        "cmip.T_errorStatus1", HFILL }},
     { &hf_cmip_errorInfo1,
       { "errorInfo", "cmip.errorInfo",
         FT_UINT32, BASE_DEC, VALS(cmip_ErrorInfo_vals), 0,
-        "ActionErrorInfo/errorInfo", HFILL }},
+        "cmip.ErrorInfo", HFILL }},
     { &hf_cmip_errorStatus2,
       { "errorStatus", "cmip.errorStatus",
         FT_UINT32, BASE_DEC, VALS(cmip_T_errorStatus2_vals), 0,
-        "AttributeError/errorStatus", HFILL }},
+        "cmip.T_errorStatus2", HFILL }},
     { &hf_cmip_attributeId2,
       { "attributeId", "cmip.attributeId",
         FT_OID, BASE_NONE, NULL, 0,
-        "AttributeError/attributeId", HFILL }},
+        "cmip.T_attributeId1", HFILL }},
     { &hf_cmip_attributeValue1,
       { "attributeValue", "cmip.attributeValue",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AttributeError/attributeValue", HFILL }},
+        "cmip.T_attributeValue1", HFILL }},
     { &hf_cmip_attributeList,
       { "attributeList", "cmip.attributeList",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "cmip.SET_OF_Attribute", HFILL }},
     { &hf_cmip_attributeList_item,
       { "Item", "cmip.attributeList_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "cmip.Attribute", HFILL }},
     { &hf_cmip_baseManagedObjectClass,
       { "baseManagedObjectClass", "cmip.baseManagedObjectClass",
         FT_UINT32, BASE_DEC, VALS(cmip_ObjectClass_vals), 0,
-        "", HFILL }},
+        "cmip.ObjectClass", HFILL }},
     { &hf_cmip_baseManagedObjectInstance,
       { "baseManagedObjectInstance", "cmip.baseManagedObjectInstance",
         FT_UINT32, BASE_DEC, VALS(cmip_ObjectInstance_vals), 0,
-        "", HFILL }},
+        "cmip.ObjectInstance", HFILL }},
     { &hf_cmip_accessControl,
       { "accessControl", "cmip.accessControl",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "cmip.AccessControl", HFILL }},
     { &hf_cmip_synchronization,
       { "synchronization", "cmip.synchronization",
         FT_UINT32, BASE_DEC, VALS(cmip_CMISSync_vals), 0,
-        "", HFILL }},
+        "cmip.CMISSync", HFILL }},
     { &hf_cmip_scope,
       { "scope", "cmip.scope",
         FT_UINT32, BASE_DEC, VALS(cmip_Scope_vals), 0,
-        "", HFILL }},
+        "cmip.Scope", HFILL }},
     { &hf_cmip_filter,
       { "filter", "cmip.filter",
         FT_UINT32, BASE_DEC, VALS(cmip_CMISFilter_vals), 0,
-        "", HFILL }},
+        "cmip.CMISFilter", HFILL }},
     { &hf_cmip_modificationList,
       { "modificationList", "cmip.modificationList",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "SetArgument/modificationList", HFILL }},
+        "cmip.SET_OF_ModificationItem", HFILL }},
     { &hf_cmip_modificationList_item,
       { "Item", "cmip.modificationList_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SetArgument/modificationList/_item", HFILL }},
+        "cmip.ModificationItem", HFILL }},
     { &hf_cmip_getResult,
       { "getResult", "cmip.getResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "LinkedReplyArgument/getResult", HFILL }},
+        "cmip.GetResult", HFILL }},
     { &hf_cmip_getListError,
       { "getListError", "cmip.getListError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "LinkedReplyArgument/getListError", HFILL }},
+        "cmip.GetListError", HFILL }},
     { &hf_cmip_setResult,
       { "setResult", "cmip.setResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "LinkedReplyArgument/setResult", HFILL }},
+        "cmip.SetResult", HFILL }},
     { &hf_cmip_setListError,
       { "setListError", "cmip.setListError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "LinkedReplyArgument/setListError", HFILL }},
+        "cmip.SetListError", HFILL }},
     { &hf_cmip_actionResult,
       { "actionResult", "cmip.actionResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "LinkedReplyArgument/actionResult", HFILL }},
+        "cmip.ActionResult", HFILL }},
     { &hf_cmip_processingFailure,
       { "processingFailure", "cmip.processingFailure",
         FT_NONE, BASE_NONE, NULL, 0,
-        "LinkedReplyArgument/processingFailure", HFILL }},
+        "cmip.ProcessingFailure", HFILL }},
     { &hf_cmip_deleteResult,
       { "deleteResult", "cmip.deleteResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "LinkedReplyArgument/deleteResult", HFILL }},
+        "cmip.DeleteResult", HFILL }},
     { &hf_cmip_actionError,
       { "actionError", "cmip.actionError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "LinkedReplyArgument/actionError", HFILL }},
+        "cmip.ActionError", HFILL }},
     { &hf_cmip_deleteError,
       { "deleteError", "cmip.deleteError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "LinkedReplyArgument/deleteError", HFILL }},
+        "cmip.DeleteError", HFILL }},
     { &hf_cmip_eventType2,
       { "eventType", "cmip.eventType",
         FT_OID, BASE_NONE, NULL, 0,
-        "EventReply/eventType", HFILL }},
+        "cmip.T_eventType2", HFILL }},
     { &hf_cmip_eventReplyInfo,
       { "eventReplyInfo", "cmip.eventReplyInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventReply/eventReplyInfo", HFILL }},
+        "cmip.T_eventReplyInfo", HFILL }},
     { &hf_cmip_eventReply,
       { "eventReply", "cmip.eventReply",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventReportResult/eventReply", HFILL }},
+        "cmip.EventReply", HFILL }},
     { &hf_cmip_eventTime,
       { "eventTime", "cmip.eventTime",
         FT_STRING, BASE_NONE, NULL, 0,
-        "EventReportArgument/eventTime", HFILL }},
+        "cmip.GeneralizedTime", HFILL }},
     { &hf_cmip_eventType3,
       { "eventType", "cmip.eventType",
         FT_OID, BASE_NONE, NULL, 0,
-        "EventReportArgument/eventType", HFILL }},
+        "cmip.T_eventType3", HFILL }},
     { &hf_cmip_eventInfo1,
       { "eventInfo", "cmip.eventInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EventReportArgument/eventInfo", HFILL }},
+        "cmip.T_eventInfo1", HFILL }},
     { &hf_cmip_managedOrSuperiorObjectInstance,
       { "managedOrSuperiorObjectInstance", "cmip.managedOrSuperiorObjectInstance",
         FT_UINT32, BASE_DEC, VALS(cmip_T_managedOrSuperiorObjectInstance_vals), 0,
-        "CreateArgument/managedOrSuperiorObjectInstance", HFILL }},
+        "cmip.T_managedOrSuperiorObjectInstance", HFILL }},
     { &hf_cmip_superiorObjectInstance,
       { "superiorObjectInstance", "cmip.superiorObjectInstance",
         FT_UINT32, BASE_DEC, VALS(cmip_ObjectInstance_vals), 0,
-        "CreateArgument/managedOrSuperiorObjectInstance/superiorObjectInstance", HFILL }},
+        "cmip.ObjectInstance", HFILL }},
     { &hf_cmip_referenceObjectInstance,
       { "referenceObjectInstance", "cmip.referenceObjectInstance",
         FT_UINT32, BASE_DEC, VALS(cmip_ObjectInstance_vals), 0,
-        "CreateArgument/referenceObjectInstance", HFILL }},
+        "cmip.ObjectInstance", HFILL }},
     { &hf_cmip_actionType2,
       { "actionType", "cmip.actionType",
         FT_OID, BASE_NONE, NULL, 0,
-        "ActionReply/actionType", HFILL }},
+        "cmip.T_actionType2", HFILL }},
     { &hf_cmip_actionReplyInfo,
       { "actionReplyInfo", "cmip.actionReplyInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ActionReply/actionReplyInfo", HFILL }},
+        "cmip.T_actionReplyInfo", HFILL }},
     { &hf_cmip_actionReply,
       { "actionReply", "cmip.actionReply",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ActionResult/actionReply", HFILL }},
+        "cmip.ActionReply", HFILL }},
     { &hf_cmip_actionInfo,
       { "actionInfo", "cmip.actionInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ActionArgument/actionInfo", HFILL }},
+        "cmip.ActionInfo", HFILL }},
     { &hf_cmip_actionType3,
       { "actionType", "cmip.actionType",
         FT_OID, BASE_NONE, NULL, 0,
-        "ActionInfo/actionType", HFILL }},
+        "cmip.T_actionType3", HFILL }},
     { &hf_cmip_actionInfoArg,
       { "actionInfoArg", "cmip.actionInfoArg",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ActionInfo/actionInfoArg", HFILL }},
+        "cmip.T_actionInfoArg", HFILL }},
     { &hf_cmip_ocglobalForm,
       { "ocglobalForm", "cmip.ocglobalForm",
         FT_OID, BASE_NONE, NULL, 0,
-        "ObjectClass/ocglobalForm", HFILL }},
+        "cmip.T_ocglobalForm", HFILL }},
     { &hf_cmip_oclocalForm,
       { "oclocalForm", "cmip.oclocalForm",
         FT_INT32, BASE_DEC, NULL, 0,
-        "ObjectClass/oclocalForm", HFILL }},
+        "cmip.T_oclocalForm", HFILL }},
     { &hf_cmip_distinguishedName,
       { "distinguishedName", "cmip.distinguishedName",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ObjectInstance/distinguishedName", HFILL }},
+        "cmip.DistinguishedName", HFILL }},
     { &hf_cmip_nonSpecificForm,
       { "nonSpecificForm", "cmip.nonSpecificForm",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "ObjectInstance/nonSpecificForm", HFILL }},
+        "cmip.OCTET_STRING", HFILL }},
     { &hf_cmip_localDistinguishedName,
       { "localDistinguishedName", "cmip.localDistinguishedName",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ObjectInstance/localDistinguishedName", HFILL }},
+        "cmip.RDNSequence", HFILL }},
     { &hf_cmip_globalForm,
       { "globalForm", "cmip.globalForm",
         FT_OID, BASE_NONE, NULL, 0,
-        "AttributeId/globalForm", HFILL }},
+        "cmip.T_globalForm", HFILL }},
     { &hf_cmip_localForm,
       { "localForm", "cmip.localForm",
         FT_INT32, BASE_DEC, NULL, 0,
-        "AttributeId/localForm", HFILL }},
+        "cmip.T_localForm", HFILL }},
     { &hf_cmip_id,
       { "id", "cmip.id",
         FT_UINT32, BASE_DEC, VALS(cmip_AttributeId_vals), 0,
-        "Attribute/id", HFILL }},
+        "cmip.AttributeId", HFILL }},
     { &hf_cmip_value,
       { "value", "cmip.value",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Attribute/value", HFILL }},
+        "cmip.T_value", HFILL }},
     { &hf_cmip_id1,
       { "id", "cmip.id",
         FT_OID, BASE_NONE, NULL, 0,
-        "AttributeValueAssertion/id", HFILL }},
+        "cmip.T_id", HFILL }},
     { &hf_cmip_value1,
       { "value", "cmip.value",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AttributeValueAssertion/value", HFILL }},
+        "cmip.T_value1", HFILL }},
     { &hf_cmip_equality,
       { "equality", "cmip.equality",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/equality", HFILL }},
+        "cmip.Attribute", HFILL }},
     { &hf_cmip_substrings,
       { "substrings", "cmip.substrings",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "FilterItem/substrings", HFILL }},
+        "cmip.T_substrings", HFILL }},
     { &hf_cmip_substrings_item,
       { "Item", "cmip.substrings_item",
         FT_UINT32, BASE_DEC, VALS(cmip_T_substrings_item_vals), 0,
-        "FilterItem/substrings/_item", HFILL }},
+        "cmip.T_substrings_item", HFILL }},
     { &hf_cmip_initialString,
       { "initialString", "cmip.initialString",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/substrings/_item/initialString", HFILL }},
+        "cmip.Attribute", HFILL }},
     { &hf_cmip_anyString,
       { "anyString", "cmip.anyString",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/substrings/_item/anyString", HFILL }},
+        "cmip.Attribute", HFILL }},
     { &hf_cmip_finalString,
       { "finalString", "cmip.finalString",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/substrings/_item/finalString", HFILL }},
+        "cmip.Attribute", HFILL }},
     { &hf_cmip_greaterOrEqual,
       { "greaterOrEqual", "cmip.greaterOrEqual",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/greaterOrEqual", HFILL }},
+        "cmip.Attribute", HFILL }},
     { &hf_cmip_lessOrEqual,
       { "lessOrEqual", "cmip.lessOrEqual",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/lessOrEqual", HFILL }},
+        "cmip.Attribute", HFILL }},
     { &hf_cmip_present,
       { "present", "cmip.present",
         FT_UINT32, BASE_DEC, VALS(cmip_AttributeId_vals), 0,
-        "FilterItem/present", HFILL }},
+        "cmip.AttributeId", HFILL }},
     { &hf_cmip_subsetOf,
       { "subsetOf", "cmip.subsetOf",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/subsetOf", HFILL }},
+        "cmip.Attribute", HFILL }},
     { &hf_cmip_supersetOf,
       { "supersetOf", "cmip.supersetOf",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/supersetOf", HFILL }},
+        "cmip.Attribute", HFILL }},
     { &hf_cmip_nonNullSetIntersection,
       { "nonNullSetIntersection", "cmip.nonNullSetIntersection",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/nonNullSetIntersection", HFILL }},
+        "cmip.Attribute", HFILL }},
     { &hf_cmip_single,
       { "single", "cmip.single",
         FT_UINT32, BASE_DEC, VALS(cmip_AE_title_vals), 0,
-        "Destination/single", HFILL }},
+        "cmip.AE_title", HFILL }},
     { &hf_cmip_multiple,
       { "multiple", "cmip.multiple",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Destination/multiple", HFILL }},
+        "cmip.SET_OF_AE_title", HFILL }},
     { &hf_cmip_multiple_item,
       { "Item", "cmip.multiple_item",
         FT_UINT32, BASE_DEC, VALS(cmip_AE_title_vals), 0,
-        "Destination/multiple/_item", HFILL }},
+        "cmip.AE_title", HFILL }},
     { &hf_cmip_ae_title_form1,
       { "ae-title-form1", "cmip.ae_title_form1",
         FT_UINT32, BASE_DEC, VALS(cmip_Name_vals), 0,
-        "AE-title/ae-title-form1", HFILL }},
+        "cmip.AE_title_form1", HFILL }},
     { &hf_cmip_ae_title_form2,
       { "ae-title-form2", "cmip.ae_title_form2",
         FT_OID, BASE_NONE, NULL, 0,
-        "AE-title/ae-title-form2", HFILL }},
+        "cmip.AE_title_form2", HFILL }},
     { &hf_cmip_rdnSequence,
       { "rdnSequence", "cmip.rdnSequence",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Name/rdnSequence", HFILL }},
+        "cmip.RDNSequence", HFILL }},
     { &hf_cmip_item,
       { "item", "cmip.item",
         FT_UINT32, BASE_DEC, VALS(cmip_FilterItem_vals), 0,
-        "CMISFilter/item", HFILL }},
+        "cmip.FilterItem", HFILL }},
     { &hf_cmip_and,
       { "and", "cmip.and",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CMISFilter/and", HFILL }},
+        "cmip.SET_OF_CMISFilter", HFILL }},
     { &hf_cmip_and_item,
       { "Item", "cmip.and_item",
         FT_UINT32, BASE_DEC, VALS(cmip_CMISFilter_vals), 0,
-        "CMISFilter/and/_item", HFILL }},
+        "cmip.CMISFilter", HFILL }},
     { &hf_cmip_or,
       { "or", "cmip.or",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CMISFilter/or", HFILL }},
+        "cmip.SET_OF_CMISFilter", HFILL }},
     { &hf_cmip_or_item,
       { "Item", "cmip.or_item",
         FT_UINT32, BASE_DEC, VALS(cmip_CMISFilter_vals), 0,
-        "CMISFilter/or/_item", HFILL }},
+        "cmip.CMISFilter", HFILL }},
     { &hf_cmip_not,
       { "not", "cmip.not",
         FT_UINT32, BASE_DEC, VALS(cmip_CMISFilter_vals), 0,
-        "CMISFilter/not", HFILL }},
+        "cmip.CMISFilter", HFILL }},
     { &hf_cmip_namedNumbers,
       { "namedNumbers", "cmip.namedNumbers",
         FT_INT32, BASE_DEC, VALS(cmip_T_namedNumbers_vals), 0,
-        "Scope/namedNumbers", HFILL }},
+        "cmip.T_namedNumbers", HFILL }},
     { &hf_cmip_individualLevels,
       { "individualLevels", "cmip.individualLevels",
         FT_INT32, BASE_DEC, NULL, 0,
-        "Scope/individualLevels", HFILL }},
+        "cmip.INTEGER", HFILL }},
     { &hf_cmip_baseToNthLevel,
       { "baseToNthLevel", "cmip.baseToNthLevel",
         FT_INT32, BASE_DEC, NULL, 0,
-        "Scope/baseToNthLevel", HFILL }},
+        "cmip.INTEGER", HFILL }},
     { &hf_cmip_attributeIdList,
       { "attributeIdList", "cmip.attributeIdList",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "GetArgument/attributeIdList", HFILL }},
+        "cmip.SET_OF_AttributeId", HFILL }},
     { &hf_cmip_attributeIdList_item,
       { "Item", "cmip.attributeIdList_item",
         FT_UINT32, BASE_DEC, VALS(cmip_AttributeId_vals), 0,
-        "GetArgument/attributeIdList/_item", HFILL }},
+        "cmip.AttributeId", HFILL }},
     { &hf_cmip_opcode,
       { "opcode", "cmip.opcode",
         FT_INT32, BASE_DEC, VALS(cmip_Opcode_vals), 0,
-        "", HFILL }},
+        "cmip.Opcode", HFILL }},
     { &hf_cmip_argument,
       { "argument", "cmip.argument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "cmip.Argument", HFILL }},
     { &hf_cmip_present1,
       { "present", "cmip.present",
         FT_INT32, BASE_DEC, NULL, 0,
-        "InvokeId/present", HFILL }},
+        "cmip.InvokeID", HFILL }},
     { &hf_cmip_absent,
       { "absent", "cmip.absent",
         FT_NONE, BASE_NONE, NULL, 0,
-        "InvokeId/absent", HFILL }},
+        "cmip.NULL", HFILL }},
     { &hf_cmip_invokeId,
       { "invokeId", "cmip.invokeId",
         FT_UINT32, BASE_DEC, VALS(cmip_InvokeId_vals), 0,
-        "", HFILL }},
+        "cmip.InvokeId", HFILL }},
     { &hf_cmip_linkedId,
       { "linkedId", "cmip.linkedId",
         FT_INT32, BASE_DEC, NULL, 0,
-        "Invoke/linkedId", HFILL }},
+        "cmip.InvokeLinkedId", HFILL }},
     { &hf_cmip_rRBody,
       { "rRBody", "cmip.rRBody",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ReturnResult/rRBody", HFILL }},
+        "cmip.ReturnResultBody", HFILL }},
     { &hf_cmip_generalProblem,
       { "generalProblem", "cmip.generalProblem",
         FT_INT32, BASE_DEC, VALS(cmip_GeneralProblem_vals), 0,
-        "RejectProb/generalProblem", HFILL }},
+        "cmip.GeneralProblem", HFILL }},
     { &hf_cmip_invokeProblem,
       { "invokeProblem", "cmip.invokeProblem",
         FT_INT32, BASE_DEC, VALS(cmip_InvokeProblem_vals), 0,
-        "RejectProb/invokeProblem", HFILL }},
+        "cmip.InvokeProblem", HFILL }},
     { &hf_cmip_returnResultProblem,
       { "returnResultProblem", "cmip.returnResultProblem",
         FT_INT32, BASE_DEC, VALS(cmip_ReturnResultProblem_vals), 0,
-        "RejectProb/returnResultProblem", HFILL }},
+        "cmip.ReturnResultProblem", HFILL }},
     { &hf_cmip_returnErrorProblem,
       { "returnErrorProblem", "cmip.returnErrorProblem",
         FT_INT32, BASE_DEC, VALS(cmip_ReturnErrorProblem_vals), 0,
-        "RejectProb/returnErrorProblem", HFILL }},
+        "cmip.ReturnErrorProblem", HFILL }},
     { &hf_cmip_rejectProblem,
       { "rejectProblem", "cmip.rejectProblem",
         FT_UINT32, BASE_DEC, VALS(cmip_RejectProb_vals), 0,
-        "Reject/rejectProblem", HFILL }},
+        "cmip.RejectProb", HFILL }},
     { &hf_cmip_invoke,
       { "invoke", "cmip.invoke",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ROS/invoke", HFILL }},
+        "cmip.Invoke", HFILL }},
     { &hf_cmip_returnResult,
       { "returnResult", "cmip.returnResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ROS/returnResult", HFILL }},
+        "cmip.ReturnResult", HFILL }},
     { &hf_cmip_returnError,
       { "returnError", "cmip.returnError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ROS/returnError", HFILL }},
+        "cmip.ReturnError", HFILL }},
     { &hf_cmip_reject,
       { "reject", "cmip.reject",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ROS/reject", HFILL }},
+        "cmip.Reject", HFILL }},
     { &hf_cmip_abortSource,
       { "abortSource", "cmip.abortSource",
         FT_UINT32, BASE_DEC, VALS(cmip_CMIPAbortSource_vals), 0,
-        "CMIPAbortInfo/abortSource", HFILL }},
+        "cmip.CMIPAbortSource", HFILL }},
     { &hf_cmip_userInfo,
       { "userInfo", "cmip.userInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "acse.EXTERNAL", HFILL }},
     { &hf_cmip_protocolVersion,
       { "protocolVersion", "cmip.protocolVersion",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "CMIPUserInfo/protocolVersion", HFILL }},
+        "cmip.ProtocolVersion", HFILL }},
     { &hf_cmip_functionalUnits,
       { "functionalUnits", "cmip.functionalUnits",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "CMIPUserInfo/functionalUnits", HFILL }},
+        "cmip.FunctionalUnits", HFILL }},
     { &hf_cmip_accessControl1,
       { "accessControl", "cmip.accessControl",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CMIPUserInfo/accessControl", HFILL }},
+        "acse.EXTERNAL", HFILL }},
     { &hf_cmip_FunctionalUnits_multipleObjectSelection,
       { "multipleObjectSelection", "cmip.multipleObjectSelection",
         FT_BOOLEAN, 8, NULL, 0x80,
index a262e08fa2131994f41b0af7bfd5331c3069afd3..2a31b39393ebbbf7f8ebd93d14baaa3d0ddbb7f7 100644 (file)
@@ -1528,395 +1528,395 @@ void proto_register_cmp(void) {
     { &hf_cmp_header,
       { "header", "cmp.header",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "cmp.PKIHeader", HFILL }},
     { &hf_cmp_body,
       { "body", "cmp.body",
         FT_UINT32, BASE_DEC, VALS(cmp_PKIBody_vals), 0,
-        "", HFILL }},
+        "cmp.PKIBody", HFILL }},
     { &hf_cmp_protection,
       { "protection", "cmp.protection",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PKIMessage/protection", HFILL }},
+        "cmp.PKIProtection", HFILL }},
     { &hf_cmp_extraCerts,
       { "extraCerts", "cmp.extraCerts",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PKIMessage/extraCerts", HFILL }},
+        "cmp.SEQUENCE_SIZE_1_MAX_OF_Certificate", HFILL }},
     { &hf_cmp_extraCerts_item,
       { "Item", "cmp.extraCerts_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PKIMessage/extraCerts/_item", HFILL }},
+        "pkix1explicit.Certificate", HFILL }},
     { &hf_cmp_pvno,
       { "pvno", "cmp.pvno",
         FT_INT32, BASE_DEC, VALS(cmp_T_pvno_vals), 0,
-        "PKIHeader/pvno", HFILL }},
+        "cmp.T_pvno", HFILL }},
     { &hf_cmp_sender,
       { "sender", "cmp.sender",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PKIHeader/sender", HFILL }},
+        "pkix1implicit.GeneralName", HFILL }},
     { &hf_cmp_recipient,
       { "recipient", "cmp.recipient",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PKIHeader/recipient", HFILL }},
+        "pkix1implicit.GeneralName", HFILL }},
     { &hf_cmp_messageTime,
       { "messageTime", "cmp.messageTime",
         FT_STRING, BASE_NONE, NULL, 0,
-        "PKIHeader/messageTime", HFILL }},
+        "cmp.GeneralizedTime", HFILL }},
     { &hf_cmp_protectionAlg,
       { "protectionAlg", "cmp.protectionAlg",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PKIHeader/protectionAlg", HFILL }},
+        "pkix1explicit.AlgorithmIdentifier", HFILL }},
     { &hf_cmp_senderKID,
       { "senderKID", "cmp.senderKID",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PKIHeader/senderKID", HFILL }},
+        "cmp.KeyIdentifier", HFILL }},
     { &hf_cmp_recipKID,
       { "recipKID", "cmp.recipKID",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PKIHeader/recipKID", HFILL }},
+        "cmp.KeyIdentifier", HFILL }},
     { &hf_cmp_transactionID,
       { "transactionID", "cmp.transactionID",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PKIHeader/transactionID", HFILL }},
+        "cmp.OCTET_STRING", HFILL }},
     { &hf_cmp_senderNonce,
       { "senderNonce", "cmp.senderNonce",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PKIHeader/senderNonce", HFILL }},
+        "cmp.OCTET_STRING", HFILL }},
     { &hf_cmp_recipNonce,
       { "recipNonce", "cmp.recipNonce",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PKIHeader/recipNonce", HFILL }},
+        "cmp.OCTET_STRING", HFILL }},
     { &hf_cmp_freeText,
       { "freeText", "cmp.freeText",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PKIHeader/freeText", HFILL }},
+        "cmp.PKIFreeText", HFILL }},
     { &hf_cmp_generalInfo,
       { "generalInfo", "cmp.generalInfo",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PKIHeader/generalInfo", HFILL }},
+        "cmp.SEQUENCE_SIZE_1_MAX_OF_InfoTypeAndValue", HFILL }},
     { &hf_cmp_generalInfo_item,
       { "Item", "cmp.generalInfo_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PKIHeader/generalInfo/_item", HFILL }},
+        "cmp.InfoTypeAndValue", HFILL }},
     { &hf_cmp_PKIFreeText_item,
       { "Item", "cmp.PKIFreeText_item",
         FT_STRING, BASE_NONE, NULL, 0,
-        "PKIFreeText/_item", HFILL }},
+        "cmp.UTF8String", HFILL }},
     { &hf_cmp_ir,
       { "ir", "cmp.ir",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PKIBody/ir", HFILL }},
+        "crmf.CertReqMessages", HFILL }},
     { &hf_cmp_ip,
       { "ip", "cmp.ip",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PKIBody/ip", HFILL }},
+        "cmp.CertRepMessage", HFILL }},
     { &hf_cmp_cr,
       { "cr", "cmp.cr",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PKIBody/cr", HFILL }},
+        "crmf.CertReqMessages", HFILL }},
     { &hf_cmp_cp,
       { "cp", "cmp.cp",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PKIBody/cp", HFILL }},
+        "cmp.CertRepMessage", HFILL }},
     { &hf_cmp_popdecc,
       { "popdecc", "cmp.popdecc",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PKIBody/popdecc", HFILL }},
+        "cmp.POPODecKeyChallContent", HFILL }},
     { &hf_cmp_popdecr,
       { "popdecr", "cmp.popdecr",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PKIBody/popdecr", HFILL }},
+        "cmp.POPODecKeyRespContent", HFILL }},
     { &hf_cmp_kur,
       { "kur", "cmp.kur",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PKIBody/kur", HFILL }},
+        "crmf.CertReqMessages", HFILL }},
     { &hf_cmp_kup,
       { "kup", "cmp.kup",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PKIBody/kup", HFILL }},
+        "cmp.CertRepMessage", HFILL }},
     { &hf_cmp_krr,
       { "krr", "cmp.krr",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PKIBody/krr", HFILL }},
+        "crmf.CertReqMessages", HFILL }},
     { &hf_cmp_krp,
       { "krp", "cmp.krp",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PKIBody/krp", HFILL }},
+        "cmp.KeyRecRepContent", HFILL }},
     { &hf_cmp_rr,
       { "rr", "cmp.rr",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PKIBody/rr", HFILL }},
+        "cmp.RevReqContent", HFILL }},
     { &hf_cmp_rp,
       { "rp", "cmp.rp",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PKIBody/rp", HFILL }},
+        "cmp.RevRepContent", HFILL }},
     { &hf_cmp_ccr,
       { "ccr", "cmp.ccr",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PKIBody/ccr", HFILL }},
+        "crmf.CertReqMessages", HFILL }},
     { &hf_cmp_ccp,
       { "ccp", "cmp.ccp",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PKIBody/ccp", HFILL }},
+        "cmp.CertRepMessage", HFILL }},
     { &hf_cmp_ckuann,
       { "ckuann", "cmp.ckuann",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PKIBody/ckuann", HFILL }},
+        "cmp.CAKeyUpdAnnContent", HFILL }},
     { &hf_cmp_cann,
       { "cann", "cmp.cann",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PKIBody/cann", HFILL }},
+        "cmp.CertAnnContent", HFILL }},
     { &hf_cmp_rann,
       { "rann", "cmp.rann",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PKIBody/rann", HFILL }},
+        "cmp.RevAnnContent", HFILL }},
     { &hf_cmp_crlann,
       { "crlann", "cmp.crlann",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PKIBody/crlann", HFILL }},
+        "cmp.CRLAnnContent", HFILL }},
     { &hf_cmp_conf,
       { "conf", "cmp.conf",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PKIBody/conf", HFILL }},
+        "cmp.PKIConfirmContent", HFILL }},
     { &hf_cmp_nested,
       { "nested", "cmp.nested",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PKIBody/nested", HFILL }},
+        "cmp.NestedMessageContent", HFILL }},
     { &hf_cmp_genm,
       { "genm", "cmp.genm",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PKIBody/genm", HFILL }},
+        "cmp.GenMsgContent", HFILL }},
     { &hf_cmp_genp,
       { "genp", "cmp.genp",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PKIBody/genp", HFILL }},
+        "cmp.GenRepContent", HFILL }},
     { &hf_cmp_error,
       { "error", "cmp.error",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PKIBody/error", HFILL }},
+        "cmp.ErrorMsgContent", HFILL }},
     { &hf_cmp_salt,
       { "salt", "cmp.salt",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PBMParameter/salt", HFILL }},
+        "cmp.OCTET_STRING", HFILL }},
     { &hf_cmp_owf,
       { "owf", "cmp.owf",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "pkix1explicit.AlgorithmIdentifier", HFILL }},
     { &hf_cmp_iterationCount,
       { "iterationCount", "cmp.iterationCount",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PBMParameter/iterationCount", HFILL }},
+        "cmp.INTEGER", HFILL }},
     { &hf_cmp_mac,
       { "mac", "cmp.mac",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "pkix1explicit.AlgorithmIdentifier", HFILL }},
     { &hf_cmp_status,
       { "status", "cmp.status",
         FT_INT32, BASE_DEC, VALS(cmp_PKIStatus_vals), 0,
-        "", HFILL }},
+        "cmp.PKIStatus", HFILL }},
     { &hf_cmp_statusString,
       { "statusString", "cmp.statusString",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PKIStatusInfo/statusString", HFILL }},
+        "cmp.PKIFreeText", HFILL }},
     { &hf_cmp_failInfo,
       { "failInfo", "cmp.failInfo",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PKIStatusInfo/failInfo", HFILL }},
+        "cmp.PKIFailureInfo", HFILL }},
     { &hf_cmp_hashAlg,
       { "hashAlg", "cmp.hashAlg",
         FT_NONE, BASE_NONE, NULL, 0,
-        "OOBCertHash/hashAlg", HFILL }},
+        "pkix1explicit.AlgorithmIdentifier", HFILL }},
     { &hf_cmp_certId,
       { "certId", "cmp.certId",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "crmf.CertId", HFILL }},
     { &hf_cmp_hashVal,
       { "hashVal", "cmp.hashVal",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "OOBCertHash/hashVal", HFILL }},
+        "cmp.BIT_STRING", HFILL }},
     { &hf_cmp_POPODecKeyChallContent_item,
       { "Item", "cmp.POPODecKeyChallContent_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "POPODecKeyChallContent/_item", HFILL }},
+        "cmp.Challenge", HFILL }},
     { &hf_cmp_witness,
       { "witness", "cmp.witness",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "Challenge/witness", HFILL }},
+        "cmp.OCTET_STRING", HFILL }},
     { &hf_cmp_challenge,
       { "challenge", "cmp.challenge",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "Challenge/challenge", HFILL }},
+        "cmp.OCTET_STRING", HFILL }},
     { &hf_cmp_POPODecKeyRespContent_item,
       { "Item", "cmp.POPODecKeyRespContent_item",
         FT_INT32, BASE_DEC, NULL, 0,
-        "POPODecKeyRespContent/_item", HFILL }},
+        "cmp.INTEGER", HFILL }},
     { &hf_cmp_caPubs,
       { "caPubs", "cmp.caPubs",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CertRepMessage/caPubs", HFILL }},
+        "cmp.SEQUENCE_SIZE_1_MAX_OF_Certificate", HFILL }},
     { &hf_cmp_caPubs_item,
       { "Item", "cmp.caPubs_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CertRepMessage/caPubs/_item", HFILL }},
+        "pkix1explicit.Certificate", HFILL }},
     { &hf_cmp_response,
       { "response", "cmp.response",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CertRepMessage/response", HFILL }},
+        "cmp.SEQUENCE_OF_CertResponse", HFILL }},
     { &hf_cmp_response_item,
       { "Item", "cmp.response_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CertRepMessage/response/_item", HFILL }},
+        "cmp.CertResponse", HFILL }},
     { &hf_cmp_certReqId,
       { "certReqId", "cmp.certReqId",
         FT_INT32, BASE_DEC, NULL, 0,
-        "CertResponse/certReqId", HFILL }},
+        "cmp.INTEGER", HFILL }},
     { &hf_cmp_status1,
       { "status", "cmp.status",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "cmp.PKIStatusInfo", HFILL }},
     { &hf_cmp_certifiedKeyPair,
       { "certifiedKeyPair", "cmp.certifiedKeyPair",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CertResponse/certifiedKeyPair", HFILL }},
+        "cmp.CertifiedKeyPair", HFILL }},
     { &hf_cmp_rspInfo,
       { "rspInfo", "cmp.rspInfo",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "CertResponse/rspInfo", HFILL }},
+        "cmp.OCTET_STRING", HFILL }},
     { &hf_cmp_certOrEncCert,
       { "certOrEncCert", "cmp.certOrEncCert",
         FT_UINT32, BASE_DEC, VALS(cmp_CertOrEncCert_vals), 0,
-        "CertifiedKeyPair/certOrEncCert", HFILL }},
+        "cmp.CertOrEncCert", HFILL }},
     { &hf_cmp_privateKey,
       { "privateKey", "cmp.privateKey",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CertifiedKeyPair/privateKey", HFILL }},
+        "crmf.EncryptedValue", HFILL }},
     { &hf_cmp_publicationInfo,
       { "publicationInfo", "cmp.publicationInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CertifiedKeyPair/publicationInfo", HFILL }},
+        "crmf.PKIPublicationInfo", HFILL }},
     { &hf_cmp_certificate,
       { "certificate", "cmp.certificate",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CertOrEncCert/certificate", HFILL }},
+        "pkix1explicit.Certificate", HFILL }},
     { &hf_cmp_encryptedCert,
       { "encryptedCert", "cmp.encryptedCert",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CertOrEncCert/encryptedCert", HFILL }},
+        "crmf.EncryptedValue", HFILL }},
     { &hf_cmp_newSigCert,
       { "newSigCert", "cmp.newSigCert",
         FT_NONE, BASE_NONE, NULL, 0,
-        "KeyRecRepContent/newSigCert", HFILL }},
+        "pkix1explicit.Certificate", HFILL }},
     { &hf_cmp_caCerts,
       { "caCerts", "cmp.caCerts",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "KeyRecRepContent/caCerts", HFILL }},
+        "cmp.SEQUENCE_SIZE_1_MAX_OF_Certificate", HFILL }},
     { &hf_cmp_caCerts_item,
       { "Item", "cmp.caCerts_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "KeyRecRepContent/caCerts/_item", HFILL }},
+        "pkix1explicit.Certificate", HFILL }},
     { &hf_cmp_keyPairHist,
       { "keyPairHist", "cmp.keyPairHist",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "KeyRecRepContent/keyPairHist", HFILL }},
+        "cmp.SEQUENCE_SIZE_1_MAX_OF_CertifiedKeyPair", HFILL }},
     { &hf_cmp_keyPairHist_item,
       { "Item", "cmp.keyPairHist_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "KeyRecRepContent/keyPairHist/_item", HFILL }},
+        "cmp.CertifiedKeyPair", HFILL }},
     { &hf_cmp_RevReqContent_item,
       { "Item", "cmp.RevReqContent_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RevReqContent/_item", HFILL }},
+        "cmp.RevDetails", HFILL }},
     { &hf_cmp_certDetails,
       { "certDetails", "cmp.certDetails",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RevDetails/certDetails", HFILL }},
+        "crmf.CertTemplate", HFILL }},
     { &hf_cmp_revocationReason,
       { "revocationReason", "cmp.revocationReason",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "RevDetails/revocationReason", HFILL }},
+        "pkix1implicit.ReasonFlags", HFILL }},
     { &hf_cmp_badSinceDate,
       { "badSinceDate", "cmp.badSinceDate",
         FT_STRING, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "cmp.GeneralizedTime", HFILL }},
     { &hf_cmp_crlEntryDetails,
       { "crlEntryDetails", "cmp.crlEntryDetails",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "RevDetails/crlEntryDetails", HFILL }},
+        "pkix1explicit.Extensions", HFILL }},
     { &hf_cmp_status2,
       { "status", "cmp.status",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "RevRepContent/status", HFILL }},
+        "cmp.SEQUENCE_SIZE_1_MAX_OF_PKIStatusInfo", HFILL }},
     { &hf_cmp_status_item,
       { "Item", "cmp.status_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RevRepContent/status/_item", HFILL }},
+        "cmp.PKIStatusInfo", HFILL }},
     { &hf_cmp_revCerts,
       { "revCerts", "cmp.revCerts",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "RevRepContent/revCerts", HFILL }},
+        "cmp.SEQUENCE_SIZE_1_MAX_OF_CertId", HFILL }},
     { &hf_cmp_revCerts_item,
       { "Item", "cmp.revCerts_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RevRepContent/revCerts/_item", HFILL }},
+        "crmf.CertId", HFILL }},
     { &hf_cmp_crls,
       { "crls", "cmp.crls",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "RevRepContent/crls", HFILL }},
+        "cmp.SEQUENCE_SIZE_1_MAX_OF_CertificateList", HFILL }},
     { &hf_cmp_crls_item,
       { "Item", "cmp.crls_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RevRepContent/crls/_item", HFILL }},
+        "pkix1explicit.CertificateList", HFILL }},
     { &hf_cmp_oldWithNew,
       { "oldWithNew", "cmp.oldWithNew",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CAKeyUpdAnnContent/oldWithNew", HFILL }},
+        "pkix1explicit.Certificate", HFILL }},
     { &hf_cmp_newWithOld,
       { "newWithOld", "cmp.newWithOld",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CAKeyUpdAnnContent/newWithOld", HFILL }},
+        "pkix1explicit.Certificate", HFILL }},
     { &hf_cmp_newWithNew,
       { "newWithNew", "cmp.newWithNew",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CAKeyUpdAnnContent/newWithNew", HFILL }},
+        "pkix1explicit.Certificate", HFILL }},
     { &hf_cmp_willBeRevokedAt,
       { "willBeRevokedAt", "cmp.willBeRevokedAt",
         FT_STRING, BASE_NONE, NULL, 0,
-        "RevAnnContent/willBeRevokedAt", HFILL }},
+        "cmp.GeneralizedTime", HFILL }},
     { &hf_cmp_crlDetails,
       { "crlDetails", "cmp.crlDetails",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "RevAnnContent/crlDetails", HFILL }},
+        "pkix1explicit.Extensions", HFILL }},
     { &hf_cmp_CRLAnnContent_item,
       { "Item", "cmp.CRLAnnContent_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CRLAnnContent/_item", HFILL }},
+        "pkix1explicit.CertificateList", HFILL }},
     { &hf_cmp_infoType,
       { "infoType", "cmp.infoType",
         FT_OID, BASE_NONE, NULL, 0,
-        "InfoTypeAndValue/infoType", HFILL }},
+        "cmp.T_infoType", HFILL }},
     { &hf_cmp_infoValue,
       { "infoValue", "cmp.infoValue",
         FT_NONE, BASE_NONE, NULL, 0,
-        "InfoTypeAndValue/infoValue", HFILL }},
+        "cmp.T_infoValue", HFILL }},
     { &hf_cmp_GenMsgContent_item,
       { "Item", "cmp.GenMsgContent_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "GenMsgContent/_item", HFILL }},
+        "cmp.InfoTypeAndValue", HFILL }},
     { &hf_cmp_GenRepContent_item,
       { "Item", "cmp.GenRepContent_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "GenRepContent/_item", HFILL }},
+        "cmp.InfoTypeAndValue", HFILL }},
     { &hf_cmp_pKIStatusInfo,
       { "pKIStatusInfo", "cmp.pKIStatusInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ErrorMsgContent/pKIStatusInfo", HFILL }},
+        "cmp.PKIStatusInfo", HFILL }},
     { &hf_cmp_errorCode,
       { "errorCode", "cmp.errorCode",
         FT_INT32, BASE_DEC, NULL, 0,
-        "ErrorMsgContent/errorCode", HFILL }},
+        "cmp.INTEGER", HFILL }},
     { &hf_cmp_errorDetails,
       { "errorDetails", "cmp.errorDetails",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ErrorMsgContent/errorDetails", HFILL }},
+        "cmp.PKIFreeText", HFILL }},
     { &hf_cmp_PKIFailureInfo_badAlg,
       { "badAlg", "cmp.badAlg",
         FT_BOOLEAN, 8, NULL, 0x80,
index 2a587c7eda7c470ffb85fd544df95aad1e9c8b25..407a06e71410937b1a915be267d6a74d621b4354 100644 (file)
@@ -1,6 +1,6 @@
 /* Do not modify this file.                                                   */
 /* It is created automatically by the ASN.1 to Wireshark dissector compiler   */
-/* ./packet-cms.c                                                             */
+/* .\packet-cms.c                                                             */
 /* ../../tools/asn2wrs.py -b -e -p cms -c cms.cnf -s packet-cms-template CryptographicMessageSyntax.asn */
 
 /* Input file: packet-cms-template.c */
@@ -1608,343 +1608,343 @@ void proto_register_cms(void) {
     { &hf_cms_ContentInfo_PDU,
       { "ContentInfo", "cms.ContentInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ContentInfo", HFILL }},
+        "cms.ContentInfo", HFILL }},
     { &hf_cms_ContentType_PDU,
       { "ContentType", "cms.ContentType",
         FT_OID, BASE_NONE, NULL, 0,
-        "ContentType", HFILL }},
+        "cms.ContentType", HFILL }},
     { &hf_cms_SignedData_PDU,
       { "SignedData", "cms.SignedData",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SignedData", HFILL }},
+        "cms.SignedData", HFILL }},
     { &hf_cms_EnvelopedData_PDU,
       { "EnvelopedData", "cms.EnvelopedData",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EnvelopedData", HFILL }},
+        "cms.EnvelopedData", HFILL }},
     { &hf_cms_DigestedData_PDU,
       { "DigestedData", "cms.DigestedData",
         FT_NONE, BASE_NONE, NULL, 0,
-        "DigestedData", HFILL }},
+        "cms.DigestedData", HFILL }},
     { &hf_cms_EncryptedData_PDU,
       { "EncryptedData", "cms.EncryptedData",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EncryptedData", HFILL }},
+        "cms.EncryptedData", HFILL }},
     { &hf_cms_AuthenticatedData_PDU,
       { "AuthenticatedData", "cms.AuthenticatedData",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AuthenticatedData", HFILL }},
+        "cms.AuthenticatedData", HFILL }},
     { &hf_cms_MessageDigest_PDU,
       { "MessageDigest", "cms.MessageDigest",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "MessageDigest", HFILL }},
+        "cms.MessageDigest", HFILL }},
     { &hf_cms_SigningTime_PDU,
       { "SigningTime", "cms.SigningTime",
         FT_UINT32, BASE_DEC, VALS(x509af_Time_vals), 0,
-        "SigningTime", HFILL }},
+        "cms.SigningTime", HFILL }},
     { &hf_cms_Countersignature_PDU,
       { "Countersignature", "cms.Countersignature",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Countersignature", HFILL }},
+        "cms.Countersignature", HFILL }},
     { &hf_cms_contentType,
       { "contentType", "cms.contentType",
         FT_OID, BASE_NONE, NULL, 0,
-        "ContentInfo/contentType", HFILL }},
+        "cms.T_contentType", HFILL }},
     { &hf_cms_content,
       { "content", "cms.content",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ContentInfo/content", HFILL }},
+        "cms.T_content", HFILL }},
     { &hf_cms_version,
       { "version", "cms.version",
         FT_INT32, BASE_DEC, VALS(cms_CMSVersion_vals), 0,
-        "", HFILL }},
+        "cms.CMSVersion", HFILL }},
     { &hf_cms_digestAlgorithms,
       { "digestAlgorithms", "cms.digestAlgorithms",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "SignedData/digestAlgorithms", HFILL }},
+        "cms.DigestAlgorithmIdentifiers", HFILL }},
     { &hf_cms_encapContentInfo,
       { "encapContentInfo", "cms.encapContentInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "cms.EncapsulatedContentInfo", HFILL }},
     { &hf_cms_certificates,
       { "certificates", "cms.certificates",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "SignedData/certificates", HFILL }},
+        "cms.CertificateSet", HFILL }},
     { &hf_cms_crls,
       { "crls", "cms.crls",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "cms.CertificateRevocationLists", HFILL }},
     { &hf_cms_signerInfos,
       { "signerInfos", "cms.signerInfos",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "SignedData/signerInfos", HFILL }},
+        "cms.SignerInfos", HFILL }},
     { &hf_cms_DigestAlgorithmIdentifiers_item,
       { "Item", "cms.DigestAlgorithmIdentifiers_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "DigestAlgorithmIdentifiers/_item", HFILL }},
+        "cms.DigestAlgorithmIdentifier", HFILL }},
     { &hf_cms_SignerInfos_item,
       { "Item", "cms.SignerInfos_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SignerInfos/_item", HFILL }},
+        "cms.SignerInfo", HFILL }},
     { &hf_cms_eContentType,
       { "eContentType", "cms.eContentType",
         FT_OID, BASE_NONE, NULL, 0,
-        "EncapsulatedContentInfo/eContentType", HFILL }},
+        "cms.T_eContentType", HFILL }},
     { &hf_cms_eContent,
       { "eContent", "cms.eContent",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "EncapsulatedContentInfo/eContent", HFILL }},
+        "cms.T_eContent", HFILL }},
     { &hf_cms_sid,
       { "sid", "cms.sid",
         FT_UINT32, BASE_DEC, VALS(cms_SignerIdentifier_vals), 0,
-        "SignerInfo/sid", HFILL }},
+        "cms.SignerIdentifier", HFILL }},
     { &hf_cms_digestAlgorithm,
       { "digestAlgorithm", "cms.digestAlgorithm",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "cms.DigestAlgorithmIdentifier", HFILL }},
     { &hf_cms_signedAttrs,
       { "signedAttrs", "cms.signedAttrs",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "SignerInfo/signedAttrs", HFILL }},
+        "cms.SignedAttributes", HFILL }},
     { &hf_cms_signatureAlgorithm,
       { "signatureAlgorithm", "cms.signatureAlgorithm",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "cms.SignatureAlgorithmIdentifier", HFILL }},
     { &hf_cms_signatureValue,
       { "signature", "cms.signature",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "SignerInfo/signature", HFILL }},
+        "cms.SignatureValue", HFILL }},
     { &hf_cms_unsignedAttrs,
       { "unsignedAttrs", "cms.unsignedAttrs",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "SignerInfo/unsignedAttrs", HFILL }},
+        "cms.UnsignedAttributes", HFILL }},
     { &hf_cms_issuerAndSerialNumber,
       { "issuerAndSerialNumber", "cms.issuerAndSerialNumber",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "cms.IssuerAndSerialNumber", HFILL }},
     { &hf_cms_subjectKeyIdentifier,
       { "subjectKeyIdentifier", "cms.subjectKeyIdentifier",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "cms.SubjectKeyIdentifier", HFILL }},
     { &hf_cms_SignedAttributes_item,
       { "Item", "cms.SignedAttributes_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SignedAttributes/_item", HFILL }},
+        "cms.Attribute", HFILL }},
     { &hf_cms_UnsignedAttributes_item,
       { "Item", "cms.UnsignedAttributes_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "UnsignedAttributes/_item", HFILL }},
+        "cms.Attribute", HFILL }},
     { &hf_cms_attrType,
       { "attrType", "cms.attrType",
         FT_OID, BASE_NONE, NULL, 0,
-        "Attribute/attrType", HFILL }},
+        "cms.T_attrType", HFILL }},
     { &hf_cms_attrValues,
       { "attrValues", "cms.attrValues",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Attribute/attrValues", HFILL }},
+        "cms.SET_OF_AttributeValue", HFILL }},
     { &hf_cms_attrValues_item,
       { "Item", "cms.attrValues_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Attribute/attrValues/_item", HFILL }},
+        "cms.AttributeValue", HFILL }},
     { &hf_cms_originatorInfo,
       { "originatorInfo", "cms.originatorInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "cms.OriginatorInfo", HFILL }},
     { &hf_cms_recipientInfos,
       { "recipientInfos", "cms.recipientInfos",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "cms.RecipientInfos", HFILL }},
     { &hf_cms_encryptedContentInfo,
       { "encryptedContentInfo", "cms.encryptedContentInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "cms.EncryptedContentInfo", HFILL }},
     { &hf_cms_unprotectedAttrs,
       { "unprotectedAttrs", "cms.unprotectedAttrs",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "cms.UnprotectedAttributes", HFILL }},
     { &hf_cms_certs,
       { "certs", "cms.certs",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "OriginatorInfo/certs", HFILL }},
+        "cms.CertificateSet", HFILL }},
     { &hf_cms_RecipientInfos_item,
       { "Item", "cms.RecipientInfos_item",
         FT_UINT32, BASE_DEC, VALS(cms_RecipientInfo_vals), 0,
-        "RecipientInfos/_item", HFILL }},
+        "cms.RecipientInfo", HFILL }},
     { &hf_cms_encryptedContentType,
       { "contentType", "cms.contentType",
         FT_OID, BASE_NONE, NULL, 0,
-        "EncryptedContentInfo/contentType", HFILL }},
+        "cms.ContentType", HFILL }},
     { &hf_cms_contentEncryptionAlgorithm,
       { "contentEncryptionAlgorithm", "cms.contentEncryptionAlgorithm",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EncryptedContentInfo/contentEncryptionAlgorithm", HFILL }},
+        "cms.ContentEncryptionAlgorithmIdentifier", HFILL }},
     { &hf_cms_encryptedContent,
       { "encryptedContent", "cms.encryptedContent",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "EncryptedContentInfo/encryptedContent", HFILL }},
+        "cms.EncryptedContent", HFILL }},
     { &hf_cms_UnprotectedAttributes_item,
       { "Item", "cms.UnprotectedAttributes_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "UnprotectedAttributes/_item", HFILL }},
+        "cms.Attribute", HFILL }},
     { &hf_cms_ktri,
       { "ktri", "cms.ktri",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RecipientInfo/ktri", HFILL }},
+        "cms.KeyTransRecipientInfo", HFILL }},
     { &hf_cms_kari,
       { "kari", "cms.kari",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RecipientInfo/kari", HFILL }},
+        "cms.KeyAgreeRecipientInfo", HFILL }},
     { &hf_cms_kekri,
       { "kekri", "cms.kekri",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RecipientInfo/kekri", HFILL }},
+        "cms.KEKRecipientInfo", HFILL }},
     { &hf_cms_rid,
       { "rid", "cms.rid",
         FT_UINT32, BASE_DEC, VALS(cms_RecipientIdentifier_vals), 0,
-        "KeyTransRecipientInfo/rid", HFILL }},
+        "cms.RecipientIdentifier", HFILL }},
     { &hf_cms_keyEncryptionAlgorithm,
       { "keyEncryptionAlgorithm", "cms.keyEncryptionAlgorithm",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "cms.KeyEncryptionAlgorithmIdentifier", HFILL }},
     { &hf_cms_encryptedKey,
       { "encryptedKey", "cms.encryptedKey",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "cms.EncryptedKey", HFILL }},
     { &hf_cms_originator,
       { "originator", "cms.originator",
         FT_UINT32, BASE_DEC, VALS(cms_OriginatorIdentifierOrKey_vals), 0,
-        "KeyAgreeRecipientInfo/originator", HFILL }},
+        "cms.OriginatorIdentifierOrKey", HFILL }},
     { &hf_cms_ukm,
       { "ukm", "cms.ukm",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "KeyAgreeRecipientInfo/ukm", HFILL }},
+        "cms.UserKeyingMaterial", HFILL }},
     { &hf_cms_recipientEncryptedKeys,
       { "recipientEncryptedKeys", "cms.recipientEncryptedKeys",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "KeyAgreeRecipientInfo/recipientEncryptedKeys", HFILL }},
+        "cms.RecipientEncryptedKeys", HFILL }},
     { &hf_cms_originatorKey,
       { "originatorKey", "cms.originatorKey",
         FT_NONE, BASE_NONE, NULL, 0,
-        "OriginatorIdentifierOrKey/originatorKey", HFILL }},
+        "cms.OriginatorPublicKey", HFILL }},
     { &hf_cms_algorithm,
       { "algorithm", "cms.algorithm",
         FT_NONE, BASE_NONE, NULL, 0,
-        "OriginatorPublicKey/algorithm", HFILL }},
+        "x509af.AlgorithmIdentifier", HFILL }},
     { &hf_cms_publicKey,
       { "publicKey", "cms.publicKey",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "OriginatorPublicKey/publicKey", HFILL }},
+        "cms.BIT_STRING", HFILL }},
     { &hf_cms_RecipientEncryptedKeys_item,
       { "Item", "cms.RecipientEncryptedKeys_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RecipientEncryptedKeys/_item", HFILL }},
+        "cms.RecipientEncryptedKey", HFILL }},
     { &hf_cms_rekRid,
       { "rid", "cms.rid",
         FT_UINT32, BASE_DEC, VALS(cms_KeyAgreeRecipientIdentifier_vals), 0,
-        "RecipientEncryptedKey/rid", HFILL }},
+        "cms.KeyAgreeRecipientIdentifier", HFILL }},
     { &hf_cms_rKeyId,
       { "rKeyId", "cms.rKeyId",
         FT_NONE, BASE_NONE, NULL, 0,
-        "KeyAgreeRecipientIdentifier/rKeyId", HFILL }},
+        "cms.RecipientKeyIdentifier", HFILL }},
     { &hf_cms_date,
       { "date", "cms.date",
         FT_STRING, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "cms.GeneralizedTime", HFILL }},
     { &hf_cms_other,
       { "other", "cms.other",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "cms.OtherKeyAttribute", HFILL }},
     { &hf_cms_kekid,
       { "kekid", "cms.kekid",
         FT_NONE, BASE_NONE, NULL, 0,
-        "KEKRecipientInfo/kekid", HFILL }},
+        "cms.KEKIdentifier", HFILL }},
     { &hf_cms_keyIdentifier,
       { "keyIdentifier", "cms.keyIdentifier",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "KEKIdentifier/keyIdentifier", HFILL }},
+        "cms.OCTET_STRING", HFILL }},
     { &hf_cms_digest,
       { "digest", "cms.digest",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "DigestedData/digest", HFILL }},
+        "cms.Digest", HFILL }},
     { &hf_cms_macAlgorithm,
       { "macAlgorithm", "cms.macAlgorithm",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AuthenticatedData/macAlgorithm", HFILL }},
+        "cms.MessageAuthenticationCodeAlgorithm", HFILL }},
     { &hf_cms_authenticatedAttributes,
       { "authenticatedAttributes", "cms.authenticatedAttributes",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "AuthenticatedData/authenticatedAttributes", HFILL }},
+        "cms.AuthAttributes", HFILL }},
     { &hf_cms_mac,
       { "mac", "cms.mac",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "AuthenticatedData/mac", HFILL }},
+        "cms.MessageAuthenticationCode", HFILL }},
     { &hf_cms_unauthenticatedAttributes,
       { "unauthenticatedAttributes", "cms.unauthenticatedAttributes",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "AuthenticatedData/unauthenticatedAttributes", HFILL }},
+        "cms.UnauthAttributes", HFILL }},
     { &hf_cms_AuthAttributes_item,
       { "Item", "cms.AuthAttributes_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AuthAttributes/_item", HFILL }},
+        "cms.Attribute", HFILL }},
     { &hf_cms_UnauthAttributes_item,
       { "Item", "cms.UnauthAttributes_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "UnauthAttributes/_item", HFILL }},
+        "cms.Attribute", HFILL }},
     { &hf_cms_CertificateRevocationLists_item,
       { "Item", "cms.CertificateRevocationLists_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CertificateRevocationLists/_item", HFILL }},
+        "x509af.CertificateList", HFILL }},
     { &hf_cms_certificate,
       { "certificate", "cms.certificate",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "x509af.Certificate", HFILL }},
     { &hf_cms_extendedCertificate,
       { "extendedCertificate", "cms.extendedCertificate",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CertificateChoices/extendedCertificate", HFILL }},
+        "cms.ExtendedCertificate", HFILL }},
     { &hf_cms_attrCert,
       { "attrCert", "cms.attrCert",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CertificateChoices/attrCert", HFILL }},
+        "x509af.AttributeCertificate", HFILL }},
     { &hf_cms_CertificateSet_item,
       { "Item", "cms.CertificateSet_item",
         FT_UINT32, BASE_DEC, VALS(cms_CertificateChoices_vals), 0,
-        "CertificateSet/_item", HFILL }},
+        "cms.CertificateChoices", HFILL }},
     { &hf_cms_issuer,
       { "issuer", "cms.issuer",
         FT_UINT32, BASE_DEC, VALS(x509if_Name_vals), 0,
-        "IssuerAndSerialNumber/issuer", HFILL }},
+        "x509if.Name", HFILL }},
     { &hf_cms_serialNumber,
       { "serialNumber", "cms.serialNumber",
         FT_INT32, BASE_DEC, NULL, 0,
-        "IssuerAndSerialNumber/serialNumber", HFILL }},
+        "x509af.CertificateSerialNumber", HFILL }},
     { &hf_cms_keyAttrId,
       { "keyAttrId", "cms.keyAttrId",
         FT_OID, BASE_NONE, NULL, 0,
-        "OtherKeyAttribute/keyAttrId", HFILL }},
+        "cms.T_keyAttrId", HFILL }},
     { &hf_cms_keyAttr,
       { "keyAttr", "cms.keyAttr",
         FT_NONE, BASE_NONE, NULL, 0,
-        "OtherKeyAttribute/keyAttr", HFILL }},
+        "cms.T_keyAttr", HFILL }},
     { &hf_cms_utcTime,
       { "utcTime", "cms.utcTime",
         FT_STRING, BASE_NONE, NULL, 0,
-        "Time/utcTime", HFILL }},
+        "cms.UTCTime", HFILL }},
     { &hf_cms_generalTime,
       { "generalTime", "cms.generalTime",
         FT_STRING, BASE_NONE, NULL, 0,
-        "Time/generalTime", HFILL }},
+        "cms.GeneralizedTime", HFILL }},
     { &hf_cms_extendedCertificateInfo,
       { "extendedCertificateInfo", "cms.extendedCertificateInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ExtendedCertificate/extendedCertificateInfo", HFILL }},
+        "cms.ExtendedCertificateInfo", HFILL }},
     { &hf_cms_signature,
       { "signature", "cms.signature",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "ExtendedCertificate/signature", HFILL }},
+        "cms.Signature", HFILL }},
     { &hf_cms_attributes,
       { "attributes", "cms.attributes",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ExtendedCertificateInfo/attributes", HFILL }},
+        "cms.UnauthAttributes", HFILL }},
 
 /*--- End of included file: packet-cms-hfarr.c ---*/
 #line 145 "packet-cms-template.c"
index 57100685c9e56b6d354a0ea7bbe53a0c76bf8c21..50c1b4563fecc63ffbf2ef0fa78d8910bf694385 100644 (file)
@@ -521,7 +521,7 @@ static const value_string crmf_T_authInfo_vals[] = {
 };
 
 static const ber_choice_t T_authInfo_choice[] = {
-  {   0, BER_CLASS_CON, 0, 0, dissect_sender_impl },
+  {   0, BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_sender_impl },
   {   1, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_publicKeyMAC },
   { 0, 0, 0, 0, NULL }
 };
@@ -603,9 +603,9 @@ const value_string crmf_POPOPrivKey_vals[] = {
 };
 
 static const ber_choice_t POPOPrivKey_choice[] = {
-  {   0, BER_CLASS_CON, 0, 0, dissect_thisMessage_impl },
-  {   1, BER_CLASS_CON, 1, 0, dissect_subsequentMessage_impl },
-  {   2, BER_CLASS_CON, 2, 0, dissect_dhMAC_impl },
+  {   0, BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_thisMessage_impl },
+  {   1, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_subsequentMessage_impl },
+  {   2, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_dhMAC_impl },
   { 0, 0, 0, 0, NULL }
 };
 
@@ -634,10 +634,10 @@ const value_string crmf_ProofOfPossession_vals[] = {
 };
 
 static const ber_choice_t ProofOfPossession_choice[] = {
-  {   0, BER_CLASS_CON, 0, 0, dissect_raVerified_impl },
-  {   1, BER_CLASS_CON, 1, 0, dissect_signature_impl },
-  {   2, BER_CLASS_CON, 2, 0, dissect_keyEncipherment_impl },
-  {   3, BER_CLASS_CON, 3, 0, dissect_keyAgreement_impl },
+  {   0, BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_raVerified_impl },
+  {   1, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_signature_impl },
+  {   2, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_keyEncipherment_impl },
+  {   3, BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_keyAgreement_impl },
   { 0, 0, 0, 0, NULL }
 };
 
@@ -876,7 +876,7 @@ const value_string crmf_EncryptedKey_vals[] = {
 
 static const ber_choice_t EncryptedKey_choice[] = {
   {   0, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_encryptedValue },
-  {   1, BER_CLASS_CON, 0, 0, dissect_envelopedData_impl },
+  {   1, BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_envelopedData_impl },
   { 0, 0, 0, 0, NULL }
 };
 
@@ -926,9 +926,9 @@ const value_string crmf_PKIArchiveOptions_vals[] = {
 };
 
 static const ber_choice_t PKIArchiveOptions_choice[] = {
-  {   0, BER_CLASS_CON, 0, 0, dissect_encryptedPrivKey_impl },
-  {   1, BER_CLASS_CON, 1, 0, dissect_keyGenParameters_impl },
-  {   2, BER_CLASS_CON, 2, 0, dissect_archiveRemGenPrivKey_impl },
+  {   0, BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_encryptedPrivKey_impl },
+  {   1, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_keyGenParameters_impl },
+  {   2, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_archiveRemGenPrivKey_impl },
   { 0, 0, 0, 0, NULL }
 };
 
@@ -1020,251 +1020,251 @@ void proto_register_crmf(void) {
     { &hf_crmf_PBMParameter_PDU,
       { "PBMParameter", "crmf.PBMParameter",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PBMParameter", HFILL }},
+        "crmf.PBMParameter", HFILL }},
     { &hf_crmf_utcTime,
       { "utcTime", "crmf.utcTime",
         FT_STRING, BASE_NONE, NULL, 0,
-        "Time/utcTime", HFILL }},
+        "crmf.UTCTime", HFILL }},
     { &hf_crmf_generalTime,
       { "generalTime", "crmf.generalTime",
         FT_STRING, BASE_NONE, NULL, 0,
-        "Time/generalTime", HFILL }},
+        "crmf.GeneralizedTime", HFILL }},
     { &hf_crmf_CertReqMessages_item,
       { "Item", "crmf.CertReqMessages_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CertReqMessages/_item", HFILL }},
+        "crmf.CertReqMsg", HFILL }},
     { &hf_crmf_certReq,
       { "certReq", "crmf.certReq",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CertReqMsg/certReq", HFILL }},
+        "crmf.CertRequest", HFILL }},
     { &hf_crmf_pop,
       { "pop", "crmf.pop",
         FT_UINT32, BASE_DEC, VALS(crmf_ProofOfPossession_vals), 0,
-        "CertReqMsg/pop", HFILL }},
+        "crmf.ProofOfPossession", HFILL }},
     { &hf_crmf_regInfo,
       { "regInfo", "crmf.regInfo",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CertReqMsg/regInfo", HFILL }},
+        "crmf.SEQUENCE_SIZE_1_MAX_OF_AttributeTypeAndValue", HFILL }},
     { &hf_crmf_regInfo_item,
       { "Item", "crmf.regInfo_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CertReqMsg/regInfo/_item", HFILL }},
+        "crmf.AttributeTypeAndValue", HFILL }},
     { &hf_crmf_certReqId,
       { "certReqId", "crmf.certReqId",
         FT_INT32, BASE_DEC, NULL, 0,
-        "CertRequest/certReqId", HFILL }},
+        "crmf.INTEGER", HFILL }},
     { &hf_crmf_certTemplate,
       { "certTemplate", "crmf.certTemplate",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CertRequest/certTemplate", HFILL }},
+        "crmf.CertTemplate", HFILL }},
     { &hf_crmf_controls,
       { "controls", "crmf.controls",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CertRequest/controls", HFILL }},
+        "crmf.Controls", HFILL }},
     { &hf_crmf_version,
       { "version", "crmf.version",
         FT_INT32, BASE_DEC, VALS(crmf_Version_vals), 0,
-        "CertTemplate/version", HFILL }},
+        "crmf.Version", HFILL }},
     { &hf_crmf_serialNumber,
       { "serialNumber", "crmf.serialNumber",
         FT_INT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "crmf.INTEGER", HFILL }},
     { &hf_crmf_signingAlg,
       { "signingAlg", "crmf.signingAlg",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CertTemplate/signingAlg", HFILL }},
+        "pkix1explicit.AlgorithmIdentifier", HFILL }},
     { &hf_crmf_template_issuer,
       { "issuer", "crmf.issuer",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CertTemplate/issuer", HFILL }},
+        "pkix1explicit.Name", HFILL }},
     { &hf_crmf_validity,
       { "validity", "crmf.validity",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CertTemplate/validity", HFILL }},
+        "crmf.OptionalValidity", HFILL }},
     { &hf_crmf_subject,
       { "subject", "crmf.subject",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CertTemplate/subject", HFILL }},
+        "pkix1explicit.Name", HFILL }},
     { &hf_crmf_publicKey,
       { "publicKey", "crmf.publicKey",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "pkix1explicit.SubjectPublicKeyInfo", HFILL }},
     { &hf_crmf_issuerUID,
       { "issuerUID", "crmf.issuerUID",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "CertTemplate/issuerUID", HFILL }},
+        "crmf.UniqueIdentifier", HFILL }},
     { &hf_crmf_subjectUID,
       { "subjectUID", "crmf.subjectUID",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "CertTemplate/subjectUID", HFILL }},
+        "crmf.UniqueIdentifier", HFILL }},
     { &hf_crmf_extensions,
       { "extensions", "crmf.extensions",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CertTemplate/extensions", HFILL }},
+        "pkix1explicit.Extensions", HFILL }},
     { &hf_crmf_notBefore,
       { "notBefore", "crmf.notBefore",
         FT_UINT32, BASE_DEC, VALS(crmf_Time_vals), 0,
-        "OptionalValidity/notBefore", HFILL }},
+        "crmf.Time", HFILL }},
     { &hf_crmf_notAfter,
       { "notAfter", "crmf.notAfter",
         FT_UINT32, BASE_DEC, VALS(crmf_Time_vals), 0,
-        "OptionalValidity/notAfter", HFILL }},
+        "crmf.Time", HFILL }},
     { &hf_crmf_Controls_item,
       { "Item", "crmf.Controls_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Controls/_item", HFILL }},
+        "crmf.AttributeTypeAndValue", HFILL }},
     { &hf_crmf_type,
       { "type", "crmf.type",
         FT_OID, BASE_NONE, NULL, 0,
-        "AttributeTypeAndValue/type", HFILL }},
+        "crmf.T_type", HFILL }},
     { &hf_crmf_value,
       { "value", "crmf.value",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AttributeTypeAndValue/value", HFILL }},
+        "crmf.T_value", HFILL }},
     { &hf_crmf_raVerified,
       { "raVerified", "crmf.raVerified",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ProofOfPossession/raVerified", HFILL }},
+        "crmf.NULL", HFILL }},
     { &hf_crmf_signature,
       { "signature", "crmf.signature",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ProofOfPossession/signature", HFILL }},
+        "crmf.POPOSigningKey", HFILL }},
     { &hf_crmf_keyEncipherment,
       { "keyEncipherment", "crmf.keyEncipherment",
         FT_UINT32, BASE_DEC, VALS(crmf_POPOPrivKey_vals), 0,
-        "ProofOfPossession/keyEncipherment", HFILL }},
+        "crmf.POPOPrivKey", HFILL }},
     { &hf_crmf_keyAgreement,
       { "keyAgreement", "crmf.keyAgreement",
         FT_UINT32, BASE_DEC, VALS(crmf_POPOPrivKey_vals), 0,
-        "ProofOfPossession/keyAgreement", HFILL }},
+        "crmf.POPOPrivKey", HFILL }},
     { &hf_crmf_poposkInput,
       { "poposkInput", "crmf.poposkInput",
         FT_NONE, BASE_NONE, NULL, 0,
-        "POPOSigningKey/poposkInput", HFILL }},
+        "crmf.POPOSigningKeyInput", HFILL }},
     { &hf_crmf_algorithmIdentifier,
       { "algorithmIdentifier", "crmf.algorithmIdentifier",
         FT_NONE, BASE_NONE, NULL, 0,
-        "POPOSigningKey/algorithmIdentifier", HFILL }},
+        "pkix1explicit.AlgorithmIdentifier", HFILL }},
     { &hf_crmf_sk_signature,
       { "signature", "crmf.signature",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "POPOSigningKey/signature", HFILL }},
+        "crmf.BIT_STRING", HFILL }},
     { &hf_crmf_authInfo,
       { "authInfo", "crmf.authInfo",
         FT_UINT32, BASE_DEC, VALS(crmf_T_authInfo_vals), 0,
-        "POPOSigningKeyInput/authInfo", HFILL }},
+        "crmf.T_authInfo", HFILL }},
     { &hf_crmf_sender,
       { "sender", "crmf.sender",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "POPOSigningKeyInput/authInfo/sender", HFILL }},
+        "pkix1implicit.GeneralName", HFILL }},
     { &hf_crmf_publicKeyMAC,
       { "publicKeyMAC", "crmf.publicKeyMAC",
         FT_NONE, BASE_NONE, NULL, 0,
-        "POPOSigningKeyInput/authInfo/publicKeyMAC", HFILL }},
+        "crmf.PKMACValue", HFILL }},
     { &hf_crmf_algId,
       { "algId", "crmf.algId",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PKMACValue/algId", HFILL }},
+        "pkix1explicit.AlgorithmIdentifier", HFILL }},
     { &hf_crmf_pkmac_value,
       { "value", "crmf.value",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PKMACValue/value", HFILL }},
+        "crmf.BIT_STRING", HFILL }},
     { &hf_crmf_salt,
       { "salt", "crmf.salt",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PBMParameter/salt", HFILL }},
+        "crmf.OCTET_STRING", HFILL }},
     { &hf_crmf_owf,
       { "owf", "crmf.owf",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PBMParameter/owf", HFILL }},
+        "pkix1explicit.AlgorithmIdentifier", HFILL }},
     { &hf_crmf_iterationCount,
       { "iterationCount", "crmf.iterationCount",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PBMParameter/iterationCount", HFILL }},
+        "crmf.INTEGER", HFILL }},
     { &hf_crmf_mac,
       { "mac", "crmf.mac",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PBMParameter/mac", HFILL }},
+        "pkix1explicit.AlgorithmIdentifier", HFILL }},
     { &hf_crmf_thisMessage,
       { "thisMessage", "crmf.thisMessage",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "POPOPrivKey/thisMessage", HFILL }},
+        "crmf.BIT_STRING", HFILL }},
     { &hf_crmf_subsequentMessage,
       { "subsequentMessage", "crmf.subsequentMessage",
         FT_INT32, BASE_DEC, VALS(crmf_SubsequentMessage_vals), 0,
-        "POPOPrivKey/subsequentMessage", HFILL }},
+        "crmf.SubsequentMessage", HFILL }},
     { &hf_crmf_dhMAC,
       { "dhMAC", "crmf.dhMAC",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "POPOPrivKey/dhMAC", HFILL }},
+        "crmf.BIT_STRING", HFILL }},
     { &hf_crmf_action,
       { "action", "crmf.action",
         FT_INT32, BASE_DEC, VALS(crmf_T_action_vals), 0,
-        "PKIPublicationInfo/action", HFILL }},
+        "crmf.T_action", HFILL }},
     { &hf_crmf_pubInfos,
       { "pubInfos", "crmf.pubInfos",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PKIPublicationInfo/pubInfos", HFILL }},
+        "crmf.SEQUENCE_SIZE_1_MAX_OF_SinglePubInfo", HFILL }},
     { &hf_crmf_pubInfos_item,
       { "Item", "crmf.pubInfos_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PKIPublicationInfo/pubInfos/_item", HFILL }},
+        "crmf.SinglePubInfo", HFILL }},
     { &hf_crmf_pubMethod,
       { "pubMethod", "crmf.pubMethod",
         FT_INT32, BASE_DEC, VALS(crmf_T_pubMethod_vals), 0,
-        "SinglePubInfo/pubMethod", HFILL }},
+        "crmf.T_pubMethod", HFILL }},
     { &hf_crmf_pubLocation,
       { "pubLocation", "crmf.pubLocation",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "SinglePubInfo/pubLocation", HFILL }},
+        "pkix1implicit.GeneralName", HFILL }},
     { &hf_crmf_encryptedPrivKey,
       { "encryptedPrivKey", "crmf.encryptedPrivKey",
         FT_UINT32, BASE_DEC, VALS(crmf_EncryptedKey_vals), 0,
-        "PKIArchiveOptions/encryptedPrivKey", HFILL }},
+        "crmf.EncryptedKey", HFILL }},
     { &hf_crmf_keyGenParameters,
       { "keyGenParameters", "crmf.keyGenParameters",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "PKIArchiveOptions/keyGenParameters", HFILL }},
+        "crmf.KeyGenParameters", HFILL }},
     { &hf_crmf_archiveRemGenPrivKey,
       { "archiveRemGenPrivKey", "crmf.archiveRemGenPrivKey",
         FT_BOOLEAN, 8, NULL, 0,
-        "PKIArchiveOptions/archiveRemGenPrivKey", HFILL }},
+        "crmf.BOOLEAN", HFILL }},
     { &hf_crmf_encryptedValue,
       { "encryptedValue", "crmf.encryptedValue",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EncryptedKey/encryptedValue", HFILL }},
+        "crmf.EncryptedValue", HFILL }},
     { &hf_crmf_envelopedData,
       { "envelopedData", "crmf.envelopedData",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EncryptedKey/envelopedData", HFILL }},
+        "cms.EnvelopedData", HFILL }},
     { &hf_crmf_intendedAlg,
       { "intendedAlg", "crmf.intendedAlg",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EncryptedValue/intendedAlg", HFILL }},
+        "pkix1explicit.AlgorithmIdentifier", HFILL }},
     { &hf_crmf_symmAlg,
       { "symmAlg", "crmf.symmAlg",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EncryptedValue/symmAlg", HFILL }},
+        "pkix1explicit.AlgorithmIdentifier", HFILL }},
     { &hf_crmf_encSymmKey,
       { "encSymmKey", "crmf.encSymmKey",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "EncryptedValue/encSymmKey", HFILL }},
+        "crmf.BIT_STRING", HFILL }},
     { &hf_crmf_keyAlg,
       { "keyAlg", "crmf.keyAlg",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EncryptedValue/keyAlg", HFILL }},
+        "pkix1explicit.AlgorithmIdentifier", HFILL }},
     { &hf_crmf_valueHint,
       { "valueHint", "crmf.valueHint",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "EncryptedValue/valueHint", HFILL }},
+        "crmf.OCTET_STRING", HFILL }},
     { &hf_crmf_encValue,
       { "encValue", "crmf.encValue",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "EncryptedValue/encValue", HFILL }},
+        "crmf.BIT_STRING", HFILL }},
     { &hf_crmf_issuer,
       { "issuer", "crmf.issuer",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "CertId/issuer", HFILL }},
+        "pkix1implicit.GeneralName", HFILL }},
 
 /*--- End of included file: packet-crmf-hfarr.c ---*/
 #line 70 "packet-crmf-template.c"
index f07433d7446078ae4116a82e9b0fc27a025266b6..a67ce83704c5b9454a2bf92c930acf433c027f6d 100644 (file)
@@ -5571,1255 +5571,1255 @@ void proto_register_dap(void) {
     { &hf_dap_securityParameters,
       { "securityParameters", "dap.securityParameters",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "dap.SecurityParameters", HFILL }},
     { &hf_dap_performer,
       { "performer", "dap.performer",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "x509if.DistinguishedName", HFILL }},
     { &hf_dap_aliasDereferenced,
       { "aliasDereferenced", "dap.aliasDereferenced",
         FT_BOOLEAN, 8, NULL, 0,
-        "", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_notification,
       { "notification", "dap.notification",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "dap.SEQUENCE_OF_Attribute", HFILL }},
     { &hf_dap_notification_item,
       { "Item", "dap.notification_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "x509if.Attribute", HFILL }},
     { &hf_dap_options,
       { "options", "dap.options",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "ServiceControls/options", HFILL }},
+        "dap.ServiceControlOptions", HFILL }},
     { &hf_dap_priority,
       { "priority", "dap.priority",
         FT_INT32, BASE_DEC, VALS(dap_T_priority_vals), 0,
-        "ServiceControls/priority", HFILL }},
+        "dap.T_priority", HFILL }},
     { &hf_dap_timeLimit,
       { "timeLimit", "dap.timeLimit",
         FT_INT32, BASE_DEC, NULL, 0,
-        "ServiceControls/timeLimit", HFILL }},
+        "dap.INTEGER", HFILL }},
     { &hf_dap_sizeLimit,
       { "sizeLimit", "dap.sizeLimit",
         FT_INT32, BASE_DEC, NULL, 0,
-        "ServiceControls/sizeLimit", HFILL }},
+        "dap.INTEGER", HFILL }},
     { &hf_dap_scopeOfReferral,
       { "scopeOfReferral", "dap.scopeOfReferral",
         FT_INT32, BASE_DEC, VALS(dap_T_scopeOfReferral_vals), 0,
-        "ServiceControls/scopeOfReferral", HFILL }},
+        "dap.T_scopeOfReferral", HFILL }},
     { &hf_dap_attributeSizeLimit,
       { "attributeSizeLimit", "dap.attributeSizeLimit",
         FT_INT32, BASE_DEC, NULL, 0,
-        "ServiceControls/attributeSizeLimit", HFILL }},
+        "dap.INTEGER", HFILL }},
     { &hf_dap_manageDSAITPlaneRef,
       { "manageDSAITPlaneRef", "dap.manageDSAITPlaneRef",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ServiceControls/manageDSAITPlaneRef", HFILL }},
+        "dap.T_manageDSAITPlaneRef", HFILL }},
     { &hf_dap_dsaName,
       { "dsaName", "dap.dsaName",
         FT_UINT32, BASE_DEC, VALS(x509if_Name_vals), 0,
-        "ServiceControls/manageDSAITPlaneRef/dsaName", HFILL }},
+        "dap.Name", HFILL }},
     { &hf_dap_agreementID,
       { "agreementID", "dap.agreementID",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ServiceControls/manageDSAITPlaneRef/agreementID", HFILL }},
+        "disp.AgreementID", HFILL }},
     { &hf_dap_serviceType,
       { "serviceType", "dap.serviceType",
         FT_OID, BASE_NONE, NULL, 0,
-        "ServiceControls/serviceType", HFILL }},
+        "dap.OBJECT_IDENTIFIER", HFILL }},
     { &hf_dap_userClass,
       { "userClass", "dap.userClass",
         FT_INT32, BASE_DEC, NULL, 0,
-        "ServiceControls/userClass", HFILL }},
+        "dap.INTEGER", HFILL }},
     { &hf_dap_attributes,
       { "attributes", "dap.attributes",
         FT_UINT32, BASE_DEC, VALS(dap_T_attributes_vals), 0,
-        "EntryInformationSelection/attributes", HFILL }},
+        "dap.T_attributes", HFILL }},
     { &hf_dap_allUserAttributes,
       { "allUserAttributes", "dap.allUserAttributes",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EntryInformationSelection/attributes/allUserAttributes", HFILL }},
+        "dap.NULL", HFILL }},
     { &hf_dap_select,
       { "select", "dap.select",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "dap.SET_OF_AttributeType", HFILL }},
     { &hf_dap_select_item,
       { "Item", "dap.select_item",
         FT_OID, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "x509if.AttributeType", HFILL }},
     { &hf_dap_infoTypes,
       { "infoTypes", "dap.infoTypes",
         FT_INT32, BASE_DEC, VALS(dap_T_infoTypes_vals), 0,
-        "EntryInformationSelection/infoTypes", HFILL }},
+        "dap.T_infoTypes", HFILL }},
     { &hf_dap_extraAttributes,
       { "extraAttributes", "dap.extraAttributes",
         FT_UINT32, BASE_DEC, VALS(dap_T_extraAttributes_vals), 0,
-        "EntryInformationSelection/extraAttributes", HFILL }},
+        "dap.T_extraAttributes", HFILL }},
     { &hf_dap_allOperationalAttributes,
       { "allOperationalAttributes", "dap.allOperationalAttributes",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EntryInformationSelection/extraAttributes/allOperationalAttributes", HFILL }},
+        "dap.NULL", HFILL }},
     { &hf_dap_contextSelection,
       { "contextSelection", "dap.contextSelection",
         FT_UINT32, BASE_DEC, VALS(dap_ContextSelection_vals), 0,
-        "EntryInformationSelection/contextSelection", HFILL }},
+        "dap.ContextSelection", HFILL }},
     { &hf_dap_returnContexts,
       { "returnContexts", "dap.returnContexts",
         FT_BOOLEAN, 8, NULL, 0,
-        "EntryInformationSelection/returnContexts", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_familyReturn,
       { "familyReturn", "dap.familyReturn",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EntryInformationSelection/familyReturn", HFILL }},
+        "dap.FamilyReturn", HFILL }},
     { &hf_dap_allContexts,
       { "allContexts", "dap.allContexts",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ContextSelection/allContexts", HFILL }},
+        "dap.NULL", HFILL }},
     { &hf_dap_selectedContexts,
       { "selectedContexts", "dap.selectedContexts",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ContextSelection/selectedContexts", HFILL }},
+        "dap.SET_OF_TypeAndContextAssertion", HFILL }},
     { &hf_dap_selectedContexts_item,
       { "Item", "dap.selectedContexts_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ContextSelection/selectedContexts/_item", HFILL }},
+        "dap.TypeAndContextAssertion", HFILL }},
     { &hf_dap_type,
       { "type", "dap.type",
         FT_OID, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "x509if.AttributeType", HFILL }},
     { &hf_dap_contextAssertions,
       { "contextAssertions", "dap.contextAssertions",
         FT_UINT32, BASE_DEC, VALS(dap_T_contextAssertions_vals), 0,
-        "TypeAndContextAssertion/contextAssertions", HFILL }},
+        "dap.T_contextAssertions", HFILL }},
     { &hf_dap_preference,
       { "preference", "dap.preference",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "TypeAndContextAssertion/contextAssertions/preference", HFILL }},
+        "dap.SEQUENCE_OF_ContextAssertion", HFILL }},
     { &hf_dap_preference_item,
       { "Item", "dap.preference_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "TypeAndContextAssertion/contextAssertions/preference/_item", HFILL }},
+        "x509if.ContextAssertion", HFILL }},
     { &hf_dap_all,
       { "all", "dap.all",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "TypeAndContextAssertion/contextAssertions/all", HFILL }},
+        "dap.SET_OF_ContextAssertion", HFILL }},
     { &hf_dap_all_item,
       { "Item", "dap.all_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "TypeAndContextAssertion/contextAssertions/all/_item", HFILL }},
+        "x509if.ContextAssertion", HFILL }},
     { &hf_dap_memberSelect,
       { "memberSelect", "dap.memberSelect",
         FT_UINT32, BASE_DEC, VALS(dap_T_memberSelect_vals), 0,
-        "FamilyReturn/memberSelect", HFILL }},
+        "dap.T_memberSelect", HFILL }},
     { &hf_dap_familySelect,
       { "familySelect", "dap.familySelect",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "FamilyReturn/familySelect", HFILL }},
+        "dap.T_familySelect", HFILL }},
     { &hf_dap_familySelect_item,
       { "Item", "dap.familySelect_item",
         FT_OID, BASE_NONE, NULL, 0,
-        "FamilyReturn/familySelect/_item", HFILL }},
+        "dap.OBJECT_IDENTIFIER", HFILL }},
     { &hf_dap_name,
       { "name", "dap.name",
         FT_UINT32, BASE_DEC, VALS(x509if_Name_vals), 0,
-        "", HFILL }},
+        "dap.Name", HFILL }},
     { &hf_dap_fromEntry,
       { "fromEntry", "dap.fromEntry",
         FT_BOOLEAN, 8, NULL, 0,
-        "", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_entry_information,
       { "information", "dap.information",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "EntryInformation/information", HFILL }},
+        "dap.T_entry_information", HFILL }},
     { &hf_dap_entry_information_item,
       { "Item", "dap.information_item",
         FT_UINT32, BASE_DEC, VALS(dap_EntryInformationItem_vals), 0,
-        "EntryInformation/information/_item", HFILL }},
+        "dap.EntryInformationItem", HFILL }},
     { &hf_dap_attributeType,
       { "attributeType", "dap.attributeType",
         FT_OID, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "x509if.AttributeType", HFILL }},
     { &hf_dap_attribute,
       { "attribute", "dap.attribute",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "x509if.Attribute", HFILL }},
     { &hf_dap_incompleteEntry,
       { "incompleteEntry", "dap.incompleteEntry",
         FT_BOOLEAN, 8, NULL, 0,
-        "EntryInformation/incompleteEntry", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_partialName,
       { "partialName", "dap.partialName",
         FT_BOOLEAN, 8, NULL, 0,
-        "EntryInformation/partialName", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_derivedEntry,
       { "derivedEntry", "dap.derivedEntry",
         FT_BOOLEAN, 8, NULL, 0,
-        "EntryInformation/derivedEntry", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_family_class,
       { "family-class", "dap.family_class",
         FT_OID, BASE_NONE, NULL, 0,
-        "FamilyEntries/family-class", HFILL }},
+        "dap.OBJECT_IDENTIFIER", HFILL }},
     { &hf_dap_familyEntries,
       { "familyEntries", "dap.familyEntries",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "FamilyEntries/familyEntries", HFILL }},
+        "dap.SEQUENCE_OF_FamilyEntry", HFILL }},
     { &hf_dap_familyEntries_item,
       { "Item", "dap.familyEntries_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FamilyEntries/familyEntries/_item", HFILL }},
+        "dap.FamilyEntry", HFILL }},
     { &hf_dap_rdn,
       { "rdn", "dap.rdn",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "x509if.RelativeDistinguishedName", HFILL }},
     { &hf_dap_family_information,
       { "information", "dap.information",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "FamilyEntry/information", HFILL }},
+        "dap.FamilyInformation", HFILL }},
     { &hf_dap_family_information_item,
       { "Item", "dap.information_item",
         FT_UINT32, BASE_DEC, VALS(dap_T_family_information_item_vals), 0,
-        "FamilyEntry/information/_item", HFILL }},
+        "dap.T_family_information_item", HFILL }},
     { &hf_dap_family_info,
       { "family-info", "dap.family_info",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "FamilyEntry/family-info", HFILL }},
+        "dap.SEQUENCE_OF_FamilyEntries", HFILL }},
     { &hf_dap_family_info_item,
       { "Item", "dap.family_info_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FamilyEntry/family-info/_item", HFILL }},
+        "dap.FamilyEntries", HFILL }},
     { &hf_dap_filter_item,
       { "item", "dap.item",
         FT_UINT32, BASE_DEC, VALS(dap_FilterItem_vals), 0,
-        "Filter/item", HFILL }},
+        "dap.FilterItem", HFILL }},
     { &hf_dap_and,
       { "and", "dap.and",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Filter/and", HFILL }},
+        "dap.SetOfFilter", HFILL }},
     { &hf_dap_or,
       { "or", "dap.or",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Filter/or", HFILL }},
+        "dap.SetOfFilter", HFILL }},
     { &hf_dap_not,
       { "not", "dap.not",
         FT_UINT32, BASE_DEC, VALS(dap_Filter_vals), 0,
-        "Filter/not", HFILL }},
+        "dap.Filter", HFILL }},
     { &hf_dap_SetOfFilter_item,
       { "Item", "dap.SetOfFilter_item",
         FT_UINT32, BASE_DEC, VALS(dap_Filter_vals), 0,
-        "SetOfFilter/_item", HFILL }},
+        "dap.Filter", HFILL }},
     { &hf_dap_equality,
       { "equality", "dap.equality",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/equality", HFILL }},
+        "x509if.AttributeValueAssertion", HFILL }},
     { &hf_dap_substrings,
       { "substrings", "dap.substrings",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/substrings", HFILL }},
+        "dap.T_substrings", HFILL }},
     { &hf_dap_sunstringType,
       { "type", "dap.type",
         FT_OID, BASE_NONE, NULL, 0,
-        "FilterItem/substrings/type", HFILL }},
+        "dap.OBJECT_IDENTIFIER", HFILL }},
     { &hf_dap_strings,
       { "strings", "dap.strings",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "FilterItem/substrings/strings", HFILL }},
+        "dap.T_strings", HFILL }},
     { &hf_dap_strings_item,
       { "Item", "dap.strings_item",
         FT_UINT32, BASE_DEC, VALS(dap_T_strings_item_vals), 0,
-        "FilterItem/substrings/strings/_item", HFILL }},
+        "dap.T_strings_item", HFILL }},
     { &hf_dap_initial,
       { "initial", "dap.initial",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/substrings/strings/_item/initial", HFILL }},
+        "dap.T_initial", HFILL }},
     { &hf_dap_any,
       { "any", "dap.any",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/substrings/strings/_item/any", HFILL }},
+        "dap.T_any", HFILL }},
     { &hf_dap_final,
       { "final", "dap.final",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/substrings/strings/_item/final", HFILL }},
+        "dap.T_final", HFILL }},
     { &hf_dap_control,
       { "control", "dap.control",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/substrings/strings/_item/control", HFILL }},
+        "x509if.Attribute", HFILL }},
     { &hf_dap_greaterOrEqual,
       { "greaterOrEqual", "dap.greaterOrEqual",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/greaterOrEqual", HFILL }},
+        "x509if.AttributeValueAssertion", HFILL }},
     { &hf_dap_lessOrEqual,
       { "lessOrEqual", "dap.lessOrEqual",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/lessOrEqual", HFILL }},
+        "x509if.AttributeValueAssertion", HFILL }},
     { &hf_dap_present,
       { "present", "dap.present",
         FT_OID, BASE_NONE, NULL, 0,
-        "FilterItem/present", HFILL }},
+        "x509if.AttributeType", HFILL }},
     { &hf_dap_approximateMatch,
       { "approximateMatch", "dap.approximateMatch",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/approximateMatch", HFILL }},
+        "x509if.AttributeValueAssertion", HFILL }},
     { &hf_dap_extensibleMatch,
       { "extensibleMatch", "dap.extensibleMatch",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/extensibleMatch", HFILL }},
+        "dap.MatchingRuleAssertion", HFILL }},
     { &hf_dap_contextPresent,
       { "contextPresent", "dap.contextPresent",
         FT_NONE, BASE_NONE, NULL, 0,
-        "FilterItem/contextPresent", HFILL }},
+        "x509if.AttributeTypeAssertion", HFILL }},
     { &hf_dap_matchingRule,
       { "matchingRule", "dap.matchingRule",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "MatchingRuleAssertion/matchingRule", HFILL }},
+        "dap.T_matchingRule", HFILL }},
     { &hf_dap_matchingRule_item,
       { "Item", "dap.matchingRule_item",
         FT_OID, BASE_NONE, NULL, 0,
-        "MatchingRuleAssertion/matchingRule/_item", HFILL }},
+        "dap.OBJECT_IDENTIFIER", HFILL }},
     { &hf_dap_matchValue,
       { "matchValue", "dap.matchValue",
         FT_NONE, BASE_NONE, NULL, 0,
-        "MatchingRuleAssertion/matchValue", HFILL }},
+        "dap.T_matchValue", HFILL }},
     { &hf_dap_dnAttributes,
       { "dnAttributes", "dap.dnAttributes",
         FT_BOOLEAN, 8, NULL, 0,
-        "MatchingRuleAssertion/dnAttributes", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_newRequest,
       { "newRequest", "dap.newRequest",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PagedResultsRequest/newRequest", HFILL }},
+        "dap.T_newRequest", HFILL }},
     { &hf_dap_pageSize,
       { "pageSize", "dap.pageSize",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PagedResultsRequest/newRequest/pageSize", HFILL }},
+        "dap.INTEGER", HFILL }},
     { &hf_dap_sortKeys,
       { "sortKeys", "dap.sortKeys",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PagedResultsRequest/newRequest/sortKeys", HFILL }},
+        "dap.SEQUENCE_OF_SortKey", HFILL }},
     { &hf_dap_sortKeys_item,
       { "Item", "dap.sortKeys_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PagedResultsRequest/newRequest/sortKeys/_item", HFILL }},
+        "dap.SortKey", HFILL }},
     { &hf_dap_reverse,
       { "reverse", "dap.reverse",
         FT_BOOLEAN, 8, NULL, 0,
-        "PagedResultsRequest/newRequest/reverse", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_unmerged,
       { "unmerged", "dap.unmerged",
         FT_BOOLEAN, 8, NULL, 0,
-        "PagedResultsRequest/newRequest/unmerged", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_queryReference,
       { "queryReference", "dap.queryReference",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "dap.OCTET_STRING", HFILL }},
     { &hf_dap_orderingRule,
       { "orderingRule", "dap.orderingRule",
         FT_OID, BASE_NONE, NULL, 0,
-        "SortKey/orderingRule", HFILL }},
+        "dap.OBJECT_IDENTIFIER", HFILL }},
     { &hf_dap_certification_path,
       { "certification-path", "dap.certification_path",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "x509af.CertificationPath", HFILL }},
     { &hf_dap_distinguished_name,
       { "name", "dap.name",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "x509if.DistinguishedName", HFILL }},
     { &hf_dap_time,
       { "time", "dap.time",
         FT_UINT32, BASE_DEC, VALS(x509af_Time_vals), 0,
-        "SecurityParameters/time", HFILL }},
+        "dap.Time", HFILL }},
     { &hf_dap_random,
       { "random", "dap.random",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "SecurityParameters/random", HFILL }},
+        "dap.BIT_STRING", HFILL }},
     { &hf_dap_target,
       { "target", "dap.target",
         FT_INT32, BASE_DEC, VALS(dap_ProtectionRequest_vals), 0,
-        "SecurityParameters/target", HFILL }},
+        "dap.ProtectionRequest", HFILL }},
     { &hf_dap_response,
       { "response", "dap.response",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "SecurityParameters/response", HFILL }},
+        "dap.BIT_STRING", HFILL }},
     { &hf_dap_operationCode,
       { "operationCode", "dap.operationCode",
         FT_UINT32, BASE_DEC, VALS(ros_Code_vals), 0,
-        "SecurityParameters/operationCode", HFILL }},
+        "ros.Code", HFILL }},
     { &hf_dap_attributeCertificationPath,
       { "attributeCertificationPath", "dap.attributeCertificationPath",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "x509af.AttributeCertificationPath", HFILL }},
     { &hf_dap_errorProtection,
       { "errorProtection", "dap.errorProtection",
         FT_INT32, BASE_DEC, VALS(dap_ErrorProtectionRequest_vals), 0,
-        "SecurityParameters/errorProtection", HFILL }},
+        "dap.ErrorProtectionRequest", HFILL }},
     { &hf_dap_errorCode,
       { "errorCode", "dap.errorCode",
         FT_UINT32, BASE_DEC, VALS(ros_Code_vals), 0,
-        "SecurityParameters/errorCode", HFILL }},
+        "ros.Code", HFILL }},
     { &hf_dap_utcTime,
       { "utcTime", "dap.utcTime",
         FT_STRING, BASE_NONE, NULL, 0,
-        "Time/utcTime", HFILL }},
+        "dap.UTCTime", HFILL }},
     { &hf_dap_generalizedTime,
       { "generalizedTime", "dap.generalizedTime",
         FT_STRING, BASE_NONE, NULL, 0,
-        "Time/generalizedTime", HFILL }},
+        "dap.GeneralizedTime", HFILL }},
     { &hf_dap_credentials,
       { "credentials", "dap.credentials",
         FT_UINT32, BASE_DEC, VALS(dap_Credentials_vals), 0,
-        "DirectoryBindArgument/credentials", HFILL }},
+        "dap.Credentials", HFILL }},
     { &hf_dap_versions,
       { "versions", "dap.versions",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "dap.Versions", HFILL }},
     { &hf_dap_simple,
       { "simple", "dap.simple",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Credentials/simple", HFILL }},
+        "dap.SimpleCredentials", HFILL }},
     { &hf_dap_strong,
       { "strong", "dap.strong",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Credentials/strong", HFILL }},
+        "dap.StrongCredentials", HFILL }},
     { &hf_dap_externalProcedure,
       { "externalProcedure", "dap.externalProcedure",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Credentials/externalProcedure", HFILL }},
+        "acse.EXTERNAL", HFILL }},
     { &hf_dap_spkm,
       { "spkm", "dap.spkm",
         FT_UINT32, BASE_DEC, VALS(dap_SpkmCredentials_vals), 0,
-        "Credentials/spkm", HFILL }},
+        "dap.SpkmCredentials", HFILL }},
     { &hf_dap_validity,
       { "validity", "dap.validity",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SimpleCredentials/validity", HFILL }},
+        "dap.T_validity", HFILL }},
     { &hf_dap_time1,
       { "time1", "dap.time1",
         FT_UINT32, BASE_DEC, VALS(dap_T_time1_vals), 0,
-        "SimpleCredentials/validity/time1", HFILL }},
+        "dap.T_time1", HFILL }},
     { &hf_dap_utc,
       { "utc", "dap.utc",
         FT_STRING, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "dap.UTCTime", HFILL }},
     { &hf_dap_gt,
       { "gt", "dap.gt",
         FT_STRING, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "dap.GeneralizedTime", HFILL }},
     { &hf_dap_time2,
       { "time2", "dap.time2",
         FT_UINT32, BASE_DEC, VALS(dap_T_time2_vals), 0,
-        "SimpleCredentials/validity/time2", HFILL }},
+        "dap.T_time2", HFILL }},
     { &hf_dap_random1,
       { "random1", "dap.random1",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "SimpleCredentials/validity/random1", HFILL }},
+        "dap.BIT_STRING", HFILL }},
     { &hf_dap_random2,
       { "random2", "dap.random2",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "SimpleCredentials/validity/random2", HFILL }},
+        "dap.BIT_STRING", HFILL }},
     { &hf_dap_password,
       { "password", "dap.password",
         FT_UINT32, BASE_DEC, VALS(dap_T_password_vals), 0,
-        "SimpleCredentials/password", HFILL }},
+        "dap.T_password", HFILL }},
     { &hf_dap_unprotected,
       { "unprotected", "dap.unprotected",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "SimpleCredentials/password/unprotected", HFILL }},
+        "dap.OCTET_STRING", HFILL }},
     { &hf_dap_protected,
       { "protected", "dap.protected",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SimpleCredentials/password/protected", HFILL }},
+        "dap.T_protected", HFILL }},
     { &hf_dap_protectedPassword,
       { "protectedPassword", "dap.protectedPassword",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "SimpleCredentials/password/protected/protectedPassword", HFILL }},
+        "dap.OCTET_STRING", HFILL }},
     { &hf_dap_algorithmIdentifier,
       { "algorithmIdentifier", "dap.algorithmIdentifier",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "x509af.AlgorithmIdentifier", HFILL }},
     { &hf_dap_encrypted,
       { "encrypted", "dap.encrypted",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "dap.BIT_STRING", HFILL }},
     { &hf_dap_bind_token,
       { "bind-token", "dap.bind_token",
         FT_NONE, BASE_NONE, NULL, 0,
-        "StrongCredentials/bind-token", HFILL }},
+        "dap.T_bind_token", HFILL }},
     { &hf_dap_req,
       { "req", "dap.req",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SpkmCredentials/req", HFILL }},
+        "dap.T_req", HFILL }},
     { &hf_dap_rep,
       { "rep", "dap.rep",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SpkmCredentials/rep", HFILL }},
+        "dap.T_rep", HFILL }},
     { &hf_dap_error,
       { "error", "dap.error",
         FT_UINT32, BASE_DEC, VALS(dap_T_error_vals), 0,
-        "DirectoryBindErrorData/error", HFILL }},
+        "dap.T_error", HFILL }},
     { &hf_dap_serviceProblem,
       { "serviceError", "dap.serviceError",
         FT_INT32, BASE_DEC, VALS(dap_ServiceProblem_vals), 0,
-        "DirectoryBindErrorData/error/serviceError", HFILL }},
+        "dap.ServiceProblem", HFILL }},
     { &hf_dap_securityProblem,
       { "securityError", "dap.securityError",
         FT_INT32, BASE_DEC, VALS(dap_SecurityProblem_vals), 0,
-        "DirectoryBindErrorData/error/securityError", HFILL }},
+        "dap.SecurityProblem", HFILL }},
     { &hf_dap_unsignedDirectoryBindError,
       { "unsignedDirectoryBindError", "dap.unsignedDirectoryBindError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "DirectoryBindError/unsignedDirectoryBindError", HFILL }},
+        "dap.DirectoryBindErrorData", HFILL }},
     { &hf_dap_signedDirectoryBindError,
       { "signedDirectoryBindError", "dap.signedDirectoryBindError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "DirectoryBindError/signedDirectoryBindError", HFILL }},
+        "dap.T_signedDirectoryBindError", HFILL }},
     { &hf_dap_directoryBindError,
       { "directoryBindError", "dap.directoryBindError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "DirectoryBindError/signedDirectoryBindError/directoryBindError", HFILL }},
+        "dap.DirectoryBindErrorData", HFILL }},
     { &hf_dap_object,
       { "object", "dap.object",
         FT_UINT32, BASE_DEC, VALS(x509if_Name_vals), 0,
-        "", HFILL }},
+        "dap.Name", HFILL }},
     { &hf_dap_selection,
       { "selection", "dap.selection",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "dap.EntryInformationSelection", HFILL }},
     { &hf_dap_modifyRightsRequest,
       { "modifyRightsRequest", "dap.modifyRightsRequest",
         FT_BOOLEAN, 8, NULL, 0,
-        "ReadArgumentData/modifyRightsRequest", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_serviceControls,
       { "serviceControls", "dap.serviceControls",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "dap.ServiceControls", HFILL }},
     { &hf_dap_requestor,
       { "requestor", "dap.requestor",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "x509if.DistinguishedName", HFILL }},
     { &hf_dap_operationProgress,
       { "operationProgress", "dap.operationProgress",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "dsp.OperationProgress", HFILL }},
     { &hf_dap_aliasedRDNs,
       { "aliasedRDNs", "dap.aliasedRDNs",
         FT_INT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "dap.INTEGER", HFILL }},
     { &hf_dap_criticalExtensions,
       { "criticalExtensions", "dap.criticalExtensions",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "", HFILL }},
+        "dap.BIT_STRING", HFILL }},
     { &hf_dap_referenceType,
       { "referenceType", "dap.referenceType",
         FT_UINT32, BASE_DEC, VALS(dsp_ReferenceType_vals), 0,
-        "", HFILL }},
+        "dsp.ReferenceType", HFILL }},
     { &hf_dap_entryOnly,
       { "entryOnly", "dap.entryOnly",
         FT_BOOLEAN, 8, NULL, 0,
-        "", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_nameResolveOnMaster,
       { "nameResolveOnMaster", "dap.nameResolveOnMaster",
         FT_BOOLEAN, 8, NULL, 0,
-        "", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_operationContexts,
       { "operationContexts", "dap.operationContexts",
         FT_UINT32, BASE_DEC, VALS(dap_ContextSelection_vals), 0,
-        "", HFILL }},
+        "dap.ContextSelection", HFILL }},
     { &hf_dap_familyGrouping,
       { "familyGrouping", "dap.familyGrouping",
         FT_UINT32, BASE_DEC, VALS(dap_FamilyGrouping_vals), 0,
-        "", HFILL }},
+        "dap.FamilyGrouping", HFILL }},
     { &hf_dap_rdnSequence,
       { "rdnSequence", "dap.rdnSequence",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "Name/rdnSequence", HFILL }},
+        "x509if.RDNSequence", HFILL }},
     { &hf_dap_unsignedReadArgument,
       { "unsignedReadArgument", "dap.unsignedReadArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ReadArgument/unsignedReadArgument", HFILL }},
+        "dap.ReadArgumentData", HFILL }},
     { &hf_dap_signedReadArgument,
       { "signedReadArgument", "dap.signedReadArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ReadArgument/signedReadArgument", HFILL }},
+        "dap.T_signedReadArgument", HFILL }},
     { &hf_dap_readArgument,
       { "readArgument", "dap.readArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ReadArgument/signedReadArgument/readArgument", HFILL }},
+        "dap.ReadArgumentData", HFILL }},
     { &hf_dap_entry,
       { "entry", "dap.entry",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "dap.EntryInformation", HFILL }},
     { &hf_dap_modifyRights,
       { "modifyRights", "dap.modifyRights",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ReadResultData/modifyRights", HFILL }},
+        "dap.ModifyRights", HFILL }},
     { &hf_dap_unsignedReadResult,
       { "unsignedReadResult", "dap.unsignedReadResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ReadResult/unsignedReadResult", HFILL }},
+        "dap.ReadResultData", HFILL }},
     { &hf_dap_signedReadResult,
       { "signedReadResult", "dap.signedReadResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ReadResult/signedReadResult", HFILL }},
+        "dap.T_signedReadResult", HFILL }},
     { &hf_dap_readResult,
       { "readResult", "dap.readResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ReadResult/signedReadResult/readResult", HFILL }},
+        "dap.ReadResultData", HFILL }},
     { &hf_dap_ModifyRights_item,
       { "Item", "dap.ModifyRights_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyRights/_item", HFILL }},
+        "dap.ModifyRights_item", HFILL }},
     { &hf_dap_item,
       { "item", "dap.item",
         FT_UINT32, BASE_DEC, VALS(dap_T_item_vals), 0,
-        "ModifyRights/_item/item", HFILL }},
+        "dap.T_item", HFILL }},
     { &hf_dap_item_entry,
       { "entry", "dap.entry",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyRights/_item/item/entry", HFILL }},
+        "dap.NULL", HFILL }},
     { &hf_dap_attribute_type,
       { "attribute", "dap.attribute",
         FT_OID, BASE_NONE, NULL, 0,
-        "ModifyRights/_item/item/attribute", HFILL }},
+        "x509if.AttributeType", HFILL }},
     { &hf_dap_value_assertion,
       { "value", "dap.value",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyRights/_item/item/value", HFILL }},
+        "x509if.AttributeValueAssertion", HFILL }},
     { &hf_dap_permission,
       { "permission", "dap.permission",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "ModifyRights/_item/permission", HFILL }},
+        "dap.T_permission", HFILL }},
     { &hf_dap_purported,
       { "purported", "dap.purported",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CompareArgumentData/purported", HFILL }},
+        "x509if.AttributeValueAssertion", HFILL }},
     { &hf_dap_unsignedCompareArgument,
       { "unsignedCompareArgument", "dap.unsignedCompareArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CompareArgument/unsignedCompareArgument", HFILL }},
+        "dap.CompareArgumentData", HFILL }},
     { &hf_dap_signedCompareArgument,
       { "signedCompareArgument", "dap.signedCompareArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CompareArgument/signedCompareArgument", HFILL }},
+        "dap.T_signedCompareArgument", HFILL }},
     { &hf_dap_compareArgument,
       { "compareArgument", "dap.compareArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CompareArgument/signedCompareArgument/compareArgument", HFILL }},
+        "dap.CompareArgumentData", HFILL }},
     { &hf_dap_matched,
       { "matched", "dap.matched",
         FT_BOOLEAN, 8, NULL, 0,
-        "CompareResultData/matched", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_matchedSubtype,
       { "matchedSubtype", "dap.matchedSubtype",
         FT_OID, BASE_NONE, NULL, 0,
-        "CompareResultData/matchedSubtype", HFILL }},
+        "x509if.AttributeType", HFILL }},
     { &hf_dap_unsignedCompareResult,
       { "unsignedCompareResult", "dap.unsignedCompareResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CompareResult/unsignedCompareResult", HFILL }},
+        "dap.CompareResultData", HFILL }},
     { &hf_dap_signedCompareResult,
       { "signedCompareResult", "dap.signedCompareResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CompareResult/signedCompareResult", HFILL }},
+        "dap.T_signedCompareResult", HFILL }},
     { &hf_dap_compareResult,
       { "compareResult", "dap.compareResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "CompareResult/signedCompareResult/compareResult", HFILL }},
+        "dap.CompareResultData", HFILL }},
     { &hf_dap_invokeID,
       { "invokeID", "dap.invokeID",
         FT_UINT32, BASE_DEC, VALS(ros_InvokeId_vals), 0,
-        "", HFILL }},
+        "ros.InvokeId", HFILL }},
     { &hf_dap_unsignedAbandonArgument,
       { "unsignedAbandonArgument", "dap.unsignedAbandonArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AbandonArgument/unsignedAbandonArgument", HFILL }},
+        "dap.AbandonArgumentData", HFILL }},
     { &hf_dap_signedAbandonArgument,
       { "signedAbandonArgument", "dap.signedAbandonArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AbandonArgument/signedAbandonArgument", HFILL }},
+        "dap.T_signedAbandonArgument", HFILL }},
     { &hf_dap_abandonArgument,
       { "abandonArgument", "dap.abandonArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AbandonArgument/signedAbandonArgument/abandonArgument", HFILL }},
+        "dap.AbandonArgumentData", HFILL }},
     { &hf_dap_null,
       { "null", "dap.null",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "dap.NULL", HFILL }},
     { &hf_dap_abandon_information,
       { "information", "dap.information",
         FT_UINT32, BASE_DEC, VALS(dap_AbandonInformation_vals), 0,
-        "AbandonResult/information", HFILL }},
+        "dap.AbandonInformation", HFILL }},
     { &hf_dap_unsignedAbandonResult,
       { "unsignedAbandonResult", "dap.unsignedAbandonResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AbandonResult/information/unsignedAbandonResult", HFILL }},
+        "dap.AbandonResultData", HFILL }},
     { &hf_dap_signedAbandonResult,
       { "signedAbandonResult", "dap.signedAbandonResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AbandonResult/information/signedAbandonResult", HFILL }},
+        "dap.T_signedAbandonResult", HFILL }},
     { &hf_dap_abandonResult,
       { "abandonResult", "dap.abandonResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AbandonResult/information/signedAbandonResult/abandonResult", HFILL }},
+        "dap.AbandonResultData", HFILL }},
     { &hf_dap_pagedResults,
       { "pagedResults", "dap.pagedResults",
         FT_UINT32, BASE_DEC, VALS(dap_PagedResultsRequest_vals), 0,
-        "", HFILL }},
+        "dap.PagedResultsRequest", HFILL }},
     { &hf_dap_listFamily,
       { "listFamily", "dap.listFamily",
         FT_BOOLEAN, 8, NULL, 0,
-        "ListArgumentData/listFamily", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_unsignedListArgument,
       { "unsignedListArgument", "dap.unsignedListArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ListArgument/unsignedListArgument", HFILL }},
+        "dap.ListArgumentData", HFILL }},
     { &hf_dap_signedListArgument,
       { "signedListArgument", "dap.signedListArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ListArgument/signedListArgument", HFILL }},
+        "dap.T_signedListArgument", HFILL }},
     { &hf_dap_listArgument,
       { "listArgument", "dap.listArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ListArgument/signedListArgument/listArgument", HFILL }},
+        "dap.ListArgumentData", HFILL }},
     { &hf_dap_listInfo,
       { "listInfo", "dap.listInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ListResultData/listInfo", HFILL }},
+        "dap.T_listInfo", HFILL }},
     { &hf_dap_subordinates,
       { "subordinates", "dap.subordinates",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ListResultData/listInfo/subordinates", HFILL }},
+        "dap.T_subordinates", HFILL }},
     { &hf_dap_subordinates_item,
       { "Item", "dap.subordinates_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ListResultData/listInfo/subordinates/_item", HFILL }},
+        "dap.T_subordinates_item", HFILL }},
     { &hf_dap_aliasEntry,
       { "aliasEntry", "dap.aliasEntry",
         FT_BOOLEAN, 8, NULL, 0,
-        "ListResultData/listInfo/subordinates/_item/aliasEntry", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_partialOutcomeQualifier,
       { "partialOutcomeQualifier", "dap.partialOutcomeQualifier",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "dap.PartialOutcomeQualifier", HFILL }},
     { &hf_dap_uncorrelatedListInfo,
       { "uncorrelatedListInfo", "dap.uncorrelatedListInfo",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ListResultData/uncorrelatedListInfo", HFILL }},
+        "dap.SET_OF_ListResult", HFILL }},
     { &hf_dap_uncorrelatedListInfo_item,
       { "Item", "dap.uncorrelatedListInfo_item",
         FT_UINT32, BASE_DEC, VALS(dap_ListResult_vals), 0,
-        "ListResultData/uncorrelatedListInfo/_item", HFILL }},
+        "dap.ListResult", HFILL }},
     { &hf_dap_unsignedListResult,
       { "unsignedListResult", "dap.unsignedListResult",
         FT_UINT32, BASE_DEC, VALS(dap_ListResultData_vals), 0,
-        "ListResult/unsignedListResult", HFILL }},
+        "dap.ListResultData", HFILL }},
     { &hf_dap_signedListResult,
       { "signedListResult", "dap.signedListResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ListResult/signedListResult", HFILL }},
+        "dap.T_signedListResult", HFILL }},
     { &hf_dap_listResult,
       { "listResult", "dap.listResult",
         FT_UINT32, BASE_DEC, VALS(dap_ListResultData_vals), 0,
-        "ListResult/signedListResult/listResult", HFILL }},
+        "dap.ListResultData", HFILL }},
     { &hf_dap_limitProblem,
       { "limitProblem", "dap.limitProblem",
         FT_INT32, BASE_DEC, VALS(dap_LimitProblem_vals), 0,
-        "PartialOutcomeQualifier/limitProblem", HFILL }},
+        "dap.LimitProblem", HFILL }},
     { &hf_dap_unexplored,
       { "unexplored", "dap.unexplored",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PartialOutcomeQualifier/unexplored", HFILL }},
+        "dap.SET_OF_ContinuationReference", HFILL }},
     { &hf_dap_unexplored_item,
       { "Item", "dap.unexplored_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "PartialOutcomeQualifier/unexplored/_item", HFILL }},
+        "dsp.ContinuationReference", HFILL }},
     { &hf_dap_unavailableCriticalExtensions,
       { "unavailableCriticalExtensions", "dap.unavailableCriticalExtensions",
         FT_BOOLEAN, 8, NULL, 0,
-        "PartialOutcomeQualifier/unavailableCriticalExtensions", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_unknownErrors,
       { "unknownErrors", "dap.unknownErrors",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "PartialOutcomeQualifier/unknownErrors", HFILL }},
+        "dap.T_unknownErrors", HFILL }},
     { &hf_dap_unknownErrors_item,
       { "Item", "dap.unknownErrors_item",
         FT_OID, BASE_NONE, NULL, 0,
-        "PartialOutcomeQualifier/unknownErrors/_item", HFILL }},
+        "dap.OBJECT_IDENTIFIER", HFILL }},
     { &hf_dap_overspecFilter,
       { "overspecFilter", "dap.overspecFilter",
         FT_UINT32, BASE_DEC, VALS(dap_Filter_vals), 0,
-        "PartialOutcomeQualifier/overspecFilter", HFILL }},
+        "dap.Filter", HFILL }},
     { &hf_dap_entryCount,
       { "entryCount", "dap.entryCount",
         FT_UINT32, BASE_DEC, VALS(dap_T_entryCount_vals), 0,
-        "PartialOutcomeQualifier/entryCount", HFILL }},
+        "dap.T_entryCount", HFILL }},
     { &hf_dap_bestEstimate,
       { "bestEstimate", "dap.bestEstimate",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PartialOutcomeQualifier/entryCount/bestEstimate", HFILL }},
+        "dap.INTEGER", HFILL }},
     { &hf_dap_lowEstimate,
       { "lowEstimate", "dap.lowEstimate",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PartialOutcomeQualifier/entryCount/lowEstimate", HFILL }},
+        "dap.INTEGER", HFILL }},
     { &hf_dap_baseObject,
       { "baseObject", "dap.baseObject",
         FT_UINT32, BASE_DEC, VALS(x509if_Name_vals), 0,
-        "SearchArgumentData/baseObject", HFILL }},
+        "dap.Name", HFILL }},
     { &hf_dap_subset,
       { "subset", "dap.subset",
         FT_INT32, BASE_DEC, VALS(dap_T_subset_vals), 0,
-        "SearchArgumentData/subset", HFILL }},
+        "dap.T_subset", HFILL }},
     { &hf_dap_filter,
       { "filter", "dap.filter",
         FT_UINT32, BASE_DEC, VALS(dap_Filter_vals), 0,
-        "SearchArgumentData/filter", HFILL }},
+        "dap.Filter", HFILL }},
     { &hf_dap_searchAliases,
       { "searchAliases", "dap.searchAliases",
         FT_BOOLEAN, 8, NULL, 0,
-        "SearchArgumentData/searchAliases", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_matchedValuesOnly,
       { "matchedValuesOnly", "dap.matchedValuesOnly",
         FT_BOOLEAN, 8, NULL, 0,
-        "SearchArgumentData/matchedValuesOnly", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_extendedFilter,
       { "extendedFilter", "dap.extendedFilter",
         FT_UINT32, BASE_DEC, VALS(dap_Filter_vals), 0,
-        "SearchArgumentData/extendedFilter", HFILL }},
+        "dap.Filter", HFILL }},
     { &hf_dap_checkOverspecified,
       { "checkOverspecified", "dap.checkOverspecified",
         FT_BOOLEAN, 8, NULL, 0,
-        "SearchArgumentData/checkOverspecified", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_relaxation,
       { "relaxation", "dap.relaxation",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SearchArgumentData/relaxation", HFILL }},
+        "x509if.RelaxationPolicy", HFILL }},
     { &hf_dap_extendedArea,
       { "extendedArea", "dap.extendedArea",
         FT_INT32, BASE_DEC, NULL, 0,
-        "SearchArgumentData/extendedArea", HFILL }},
+        "dap.INTEGER", HFILL }},
     { &hf_dap_hierarchySelections,
       { "hierarchySelections", "dap.hierarchySelections",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "SearchArgumentData/hierarchySelections", HFILL }},
+        "dap.HierarchySelections", HFILL }},
     { &hf_dap_searchControlOptions,
       { "searchControlOptions", "dap.searchControlOptions",
         FT_BYTES, BASE_HEX, NULL, 0,
-        "SearchArgumentData/searchControlOptions", HFILL }},
+        "dap.SearchControlOptions", HFILL }},
     { &hf_dap_joinArguments,
       { "joinArguments", "dap.joinArguments",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "SearchArgumentData/joinArguments", HFILL }},
+        "dap.SEQUENCE_SIZE_1_MAX_OF_JoinArgument", HFILL }},
     { &hf_dap_joinArguments_item,
       { "Item", "dap.joinArguments_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SearchArgumentData/joinArguments/_item", HFILL }},
+        "dap.JoinArgument", HFILL }},
     { &hf_dap_joinType,
       { "joinType", "dap.joinType",
         FT_UINT32, BASE_DEC, VALS(dap_T_joinType_vals), 0,
-        "SearchArgumentData/joinType", HFILL }},
+        "dap.T_joinType", HFILL }},
     { &hf_dap_unsignedSearchArgument,
       { "unsignedSearchArgument", "dap.unsignedSearchArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SearchArgument/unsignedSearchArgument", HFILL }},
+        "dap.SearchArgumentData", HFILL }},
     { &hf_dap_signedSearchArgument,
       { "signedSearchArgument", "dap.signedSearchArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SearchArgument/signedSearchArgument", HFILL }},
+        "dap.T_signedSearchArgument", HFILL }},
     { &hf_dap_searchArgument,
       { "searchArgument", "dap.searchArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SearchArgument/signedSearchArgument/searchArgument", HFILL }},
+        "dap.SearchArgumentData", HFILL }},
     { &hf_dap_joinBaseObject,
       { "joinBaseObject", "dap.joinBaseObject",
         FT_UINT32, BASE_DEC, VALS(x509if_Name_vals), 0,
-        "JoinArgument/joinBaseObject", HFILL }},
+        "dap.Name", HFILL }},
     { &hf_dap_domainLocalID,
       { "domainLocalID", "dap.domainLocalID",
         FT_UINT32, BASE_DEC, VALS(x509sat_DirectoryString_vals), 0,
-        "JoinArgument/domainLocalID", HFILL }},
+        "dap.DomainLocalID", HFILL }},
     { &hf_dap_joinSubset,
       { "joinSubset", "dap.joinSubset",
         FT_UINT32, BASE_DEC, VALS(dap_T_joinSubset_vals), 0,
-        "JoinArgument/joinSubset", HFILL }},
+        "dap.T_joinSubset", HFILL }},
     { &hf_dap_joinFilter,
       { "joinFilter", "dap.joinFilter",
         FT_UINT32, BASE_DEC, VALS(dap_Filter_vals), 0,
-        "JoinArgument/joinFilter", HFILL }},
+        "dap.Filter", HFILL }},
     { &hf_dap_joinAttributes,
       { "joinAttributes", "dap.joinAttributes",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "JoinArgument/joinAttributes", HFILL }},
+        "dap.SEQUENCE_OF_JoinAttPair", HFILL }},
     { &hf_dap_joinAttributes_item,
       { "Item", "dap.joinAttributes_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "JoinArgument/joinAttributes/_item", HFILL }},
+        "dap.JoinAttPair", HFILL }},
     { &hf_dap_joinSelection,
       { "joinSelection", "dap.joinSelection",
         FT_NONE, BASE_NONE, NULL, 0,
-        "JoinArgument/joinSelection", HFILL }},
+        "dap.EntryInformationSelection", HFILL }},
     { &hf_dap_baseAtt,
       { "baseAtt", "dap.baseAtt",
         FT_OID, BASE_NONE, NULL, 0,
-        "JoinAttPair/baseAtt", HFILL }},
+        "x509if.AttributeType", HFILL }},
     { &hf_dap_joinAtt,
       { "joinAtt", "dap.joinAtt",
         FT_OID, BASE_NONE, NULL, 0,
-        "JoinAttPair/joinAtt", HFILL }},
+        "x509if.AttributeType", HFILL }},
     { &hf_dap_joinContext,
       { "joinContext", "dap.joinContext",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "JoinAttPair/joinContext", HFILL }},
+        "dap.SEQUENCE_OF_JoinContextType", HFILL }},
     { &hf_dap_joinContext_item,
       { "Item", "dap.joinContext_item",
         FT_OID, BASE_NONE, NULL, 0,
-        "JoinAttPair/joinContext/_item", HFILL }},
+        "dap.JoinContextType", HFILL }},
     { &hf_dap_searchInfo,
       { "searchInfo", "dap.searchInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SearchResultData/searchInfo", HFILL }},
+        "dap.T_searchInfo", HFILL }},
     { &hf_dap_entries,
       { "entries", "dap.entries",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "SearchResultData/searchInfo/entries", HFILL }},
+        "dap.SET_OF_EntryInformation", HFILL }},
     { &hf_dap_entries_item,
       { "Item", "dap.entries_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SearchResultData/searchInfo/entries/_item", HFILL }},
+        "dap.EntryInformation", HFILL }},
     { &hf_dap_altMatching,
       { "altMatching", "dap.altMatching",
         FT_BOOLEAN, 8, NULL, 0,
-        "SearchResultData/searchInfo/altMatching", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_uncorrelatedSearchInfo,
       { "uncorrelatedSearchInfo", "dap.uncorrelatedSearchInfo",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "SearchResultData/uncorrelatedSearchInfo", HFILL }},
+        "dap.SET_OF_SearchResult", HFILL }},
     { &hf_dap_uncorrelatedSearchInfo_item,
       { "Item", "dap.uncorrelatedSearchInfo_item",
         FT_UINT32, BASE_DEC, VALS(dap_SearchResult_vals), 0,
-        "SearchResultData/uncorrelatedSearchInfo/_item", HFILL }},
+        "dap.SearchResult", HFILL }},
     { &hf_dap_unsignedSearchResult,
       { "unsignedSearchResult", "dap.unsignedSearchResult",
         FT_UINT32, BASE_DEC, VALS(dap_SearchResultData_vals), 0,
-        "SearchResult/unsignedSearchResult", HFILL }},
+        "dap.SearchResultData", HFILL }},
     { &hf_dap_signedSearchResult,
       { "signedSearchResult", "dap.signedSearchResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SearchResult/signedSearchResult", HFILL }},
+        "dap.T_signedSearchResult", HFILL }},
     { &hf_dap_searchResult,
       { "searchResult", "dap.searchResult",
         FT_UINT32, BASE_DEC, VALS(dap_SearchResultData_vals), 0,
-        "SearchResult/signedSearchResult/searchResult", HFILL }},
+        "dap.SearchResultData", HFILL }},
     { &hf_dap_add_entry,
       { "entry", "dap.entry",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "AddEntryArgumentData/entry", HFILL }},
+        "dap.SET_OF_Attribute", HFILL }},
     { &hf_dap_add_entry_item,
       { "Item", "dap.entry_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AddEntryArgumentData/entry/_item", HFILL }},
+        "x509if.Attribute", HFILL }},
     { &hf_dap_targetSystem,
       { "targetSystem", "dap.targetSystem",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AddEntryArgumentData/targetSystem", HFILL }},
+        "dsp.AccessPoint", HFILL }},
     { &hf_dap_unsignedAddEntryArgument,
       { "unsignedAddEntryArgument", "dap.unsignedAddEntryArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AddEntryArgument/unsignedAddEntryArgument", HFILL }},
+        "dap.AddEntryArgumentData", HFILL }},
     { &hf_dap_signedAddEntryArgument,
       { "signedAddEntryArgument", "dap.signedAddEntryArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AddEntryArgument/signedAddEntryArgument", HFILL }},
+        "dap.T_signedAddEntryArgument", HFILL }},
     { &hf_dap_addEntryArgument,
       { "addEntryArgument", "dap.addEntryArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AddEntryArgument/signedAddEntryArgument/addEntryArgument", HFILL }},
+        "dap.AddEntryArgumentData", HFILL }},
     { &hf_dap_add_entry_information,
       { "information", "dap.information",
         FT_UINT32, BASE_DEC, VALS(dap_AddEntryInformation_vals), 0,
-        "AddEntryResult/information", HFILL }},
+        "dap.AddEntryInformation", HFILL }},
     { &hf_dap_unsignedAddEntryResult,
       { "unsignedAddEntryResult", "dap.unsignedAddEntryResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AddEntryResult/information/unsignedAddEntryResult", HFILL }},
+        "dap.AddEntryResultData", HFILL }},
     { &hf_dap_signedAddEntryResult,
       { "signedAddEntryResult", "dap.signedAddEntryResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AddEntryResult/information/signedAddEntryResult", HFILL }},
+        "dap.T_signedAddEntryResult", HFILL }},
     { &hf_dap_addEntryResult,
       { "addEntryResult", "dap.addEntryResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AddEntryResult/information/signedAddEntryResult/addEntryResult", HFILL }},
+        "dap.AddEntryResultData", HFILL }},
     { &hf_dap_unsignedRemoveEntryArgument,
       { "unsignedRemoveEntryArgument", "dap.unsignedRemoveEntryArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RemoveEntryArgument/unsignedRemoveEntryArgument", HFILL }},
+        "dap.RemoveEntryArgumentData", HFILL }},
     { &hf_dap_signedRemoveEntryArgument,
       { "signedRemoveEntryArgument", "dap.signedRemoveEntryArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RemoveEntryArgument/signedRemoveEntryArgument", HFILL }},
+        "dap.T_signedRemoveEntryArgument", HFILL }},
     { &hf_dap_removeEntryArgument,
       { "removeEntryArgument", "dap.removeEntryArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RemoveEntryArgument/signedRemoveEntryArgument/removeEntryArgument", HFILL }},
+        "dap.RemoveEntryArgumentData", HFILL }},
     { &hf_dap_remove_entry_information,
       { "information", "dap.information",
         FT_UINT32, BASE_DEC, VALS(dap_RemoveEntryInformation_vals), 0,
-        "RemoveEntryResult/information", HFILL }},
+        "dap.RemoveEntryInformation", HFILL }},
     { &hf_dap_unsignedRemoveEntryResult,
       { "unsignedRemoveEntryResult", "dap.unsignedRemoveEntryResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RemoveEntryResult/information/unsignedRemoveEntryResult", HFILL }},
+        "dap.RemoveEntryResultData", HFILL }},
     { &hf_dap_signedRemoveEntryResult,
       { "signedRemoveEntryResult", "dap.signedRemoveEntryResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RemoveEntryResult/information/signedRemoveEntryResult", HFILL }},
+        "dap.T_signedRemoveEntryResult", HFILL }},
     { &hf_dap_removeEntryResult,
       { "removeEntryResult", "dap.removeEntryResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "RemoveEntryResult/information/signedRemoveEntryResult/removeEntryResult", HFILL }},
+        "dap.RemoveEntryResultData", HFILL }},
     { &hf_dap_changes,
       { "changes", "dap.changes",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ModifyEntryArgumentData/changes", HFILL }},
+        "dap.SEQUENCE_OF_EntryModification", HFILL }},
     { &hf_dap_changes_item,
       { "Item", "dap.changes_item",
         FT_UINT32, BASE_DEC, VALS(dap_EntryModification_vals), 0,
-        "ModifyEntryArgumentData/changes/_item", HFILL }},
+        "dap.EntryModification", HFILL }},
     { &hf_dap_unsignedModifyEntryArgument,
       { "unsignedModifyEntryArgument", "dap.unsignedModifyEntryArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyEntryArgument/unsignedModifyEntryArgument", HFILL }},
+        "dap.ModifyEntryArgumentData", HFILL }},
     { &hf_dap_signedModifyEntryArgument,
       { "signedModifyEntryArgument", "dap.signedModifyEntryArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyEntryArgument/signedModifyEntryArgument", HFILL }},
+        "dap.T_signedModifyEntryArgument", HFILL }},
     { &hf_dap_modifyEntryArgument,
       { "modifyEntryArgument", "dap.modifyEntryArgument",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyEntryArgument/signedModifyEntryArgument/modifyEntryArgument", HFILL }},
+        "dap.ModifyEntryArgumentData", HFILL }},
     { &hf_dap_modify_entry_information,
       { "information", "dap.information",
         FT_UINT32, BASE_DEC, VALS(dap_ModifyEntryInformation_vals), 0,
-        "ModifyEntryResult/information", HFILL }},
+        "dap.ModifyEntryInformation", HFILL }},
     { &hf_dap_unsignedModifyEntryResult,
       { "unsignedModifyEntryResult", "dap.unsignedModifyEntryResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyEntryResult/information/unsignedModifyEntryResult", HFILL }},
+        "dap.ModifyEntryResultData", HFILL }},
     { &hf_dap_signedModifyEntryResult,
       { "signedModifyEntryResult", "dap.signedModifyEntryResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyEntryResult/information/signedModifyEntryResult", HFILL }},
+        "dap.T_signedModifyEntryResult", HFILL }},
     { &hf_dap_modifyEntryResult,
       { "modifyEntryResult", "dap.modifyEntryResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyEntryResult/information/signedModifyEntryResult/modifyEntryResult", HFILL }},
+        "dap.ModifyEntryResultData", HFILL }},
     { &hf_dap_addAttribute,
       { "addAttribute", "dap.addAttribute",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EntryModification/addAttribute", HFILL }},
+        "x509if.Attribute", HFILL }},
     { &hf_dap_removeAttribute,
       { "removeAttribute", "dap.removeAttribute",
         FT_OID, BASE_NONE, NULL, 0,
-        "EntryModification/removeAttribute", HFILL }},
+        "x509if.AttributeType", HFILL }},
     { &hf_dap_addValues,
       { "addValues", "dap.addValues",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EntryModification/addValues", HFILL }},
+        "x509if.Attribute", HFILL }},
     { &hf_dap_removeValues,
       { "removeValues", "dap.removeValues",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EntryModification/removeValues", HFILL }},
+        "x509if.Attribute", HFILL }},
     { &hf_dap_alterValues,
       { "alterValues", "dap.alterValues",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EntryModification/alterValues", HFILL }},
+        "crmf.AttributeTypeAndValue", HFILL }},
     { &hf_dap_resetValue,
       { "resetValue", "dap.resetValue",
         FT_OID, BASE_NONE, NULL, 0,
-        "EntryModification/resetValue", HFILL }},
+        "x509if.AttributeType", HFILL }},
     { &hf_dap_newRDN,
       { "newRDN", "dap.newRDN",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "", HFILL }},
+        "x509if.RelativeDistinguishedName", HFILL }},
     { &hf_dap_deleteOldRDN,
       { "deleteOldRDN", "dap.deleteOldRDN",
         FT_BOOLEAN, 8, NULL, 0,
-        "ModifyDNArgument/deleteOldRDN", HFILL }},
+        "dap.BOOLEAN", HFILL }},
     { &hf_dap_newSuperior,
       { "newSuperior", "dap.newSuperior",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ModifyDNArgument/newSuperior", HFILL }},
+        "x509if.DistinguishedName", HFILL }},
     { &hf_dap_modify_dn_information,
       { "information", "dap.information",
         FT_UINT32, BASE_DEC, VALS(dap_ModifyDNInformation_vals), 0,
-        "ModifyDNResult/information", HFILL }},
+        "dap.ModifyDNInformation", HFILL }},
     { &hf_dap_unsignedModifyDNResult,
       { "unsignedModifyDNResult", "dap.unsignedModifyDNResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyDNResult/information/unsignedModifyDNResult", HFILL }},
+        "dap.ModifyDNResultData", HFILL }},
     { &hf_dap_signedModifyDNResult,
       { "signedModifyDNResult", "dap.signedModifyDNResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyDNResult/information/signedModifyDNResult", HFILL }},
+        "dap.T_signedModifyDNResult", HFILL }},
     { &hf_dap_modifyDNResult,
       { "modifyDNResult", "dap.modifyDNResult",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModifyDNResult/information/signedModifyDNResult/modifyDNResult", HFILL }},
+        "dap.ModifyDNResultData", HFILL }},
     { &hf_dap_unsignedAbandoned,
       { "unsignedAbandoned", "dap.unsignedAbandoned",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Abandoned/unsignedAbandoned", HFILL }},
+        "dap.AbandonedData", HFILL }},
     { &hf_dap_signedAbandoned,
       { "signedAbandoned", "dap.signedAbandoned",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Abandoned/signedAbandoned", HFILL }},
+        "dap.T_signedAbandoned", HFILL }},
     { &hf_dap_abandoned,
       { "abandoned", "dap.abandoned",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Abandoned/signedAbandoned/abandoned", HFILL }},
+        "dap.AbandonedData", HFILL }},
     { &hf_dap_abandon_failed_problem,
       { "problem", "dap.problem",
         FT_INT32, BASE_DEC, VALS(dap_AbandonProblem_vals), 0,
-        "AbandonFailedErrorData/problem", HFILL }},
+        "dap.AbandonProblem", HFILL }},
     { &hf_dap_operation,
       { "operation", "dap.operation",
         FT_UINT32, BASE_DEC, VALS(ros_InvokeId_vals), 0,
-        "AbandonFailedErrorData/operation", HFILL }},
+        "ros.InvokeId", HFILL }},
     { &hf_dap_unsignedAbandonFailedError,
       { "unsignedAbandonFailedError", "dap.unsignedAbandonFailedError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AbandonFailedError/unsignedAbandonFailedError", HFILL }},
+        "dap.AbandonFailedErrorData", HFILL }},
     { &hf_dap_signedAbandonFailedError,
       { "signedAbandonFailedError", "dap.signedAbandonFailedError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AbandonFailedError/signedAbandonFailedError", HFILL }},
+        "dap.T_signedAbandonFailedError", HFILL }},
     { &hf_dap_abandonFailedError,
       { "abandonFailedError", "dap.abandonFailedError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AbandonFailedError/signedAbandonFailedError/abandonFailedError", HFILL }},
+        "dap.AbandonFailedErrorData", HFILL }},
     { &hf_dap_problems,
       { "problems", "dap.problems",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "AttributeErrorData/problems", HFILL }},
+        "dap.T_problems", HFILL }},
     { &hf_dap_problems_item,
       { "Item", "dap.problems_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AttributeErrorData/problems/_item", HFILL }},
+        "dap.T_problems_item", HFILL }},
     { &hf_dap_attribute_error_problem,
       { "problem", "dap.problem",
         FT_INT32, BASE_DEC, VALS(dap_AttributeProblem_vals), 0,
-        "AttributeErrorData/problems/_item/problem", HFILL }},
+        "dap.AttributeProblem", HFILL }},
     { &hf_dap_value,
       { "value", "dap.value",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AttributeErrorData/problems/_item/value", HFILL }},
+        "x509if.AttributeValue", HFILL }},
     { &hf_dap_unsignedAttributeError,
       { "unsignedAttributeError", "dap.unsignedAttributeError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AttributeError/unsignedAttributeError", HFILL }},
+        "dap.AttributeErrorData", HFILL }},
     { &hf_dap_signedAttributeError,
       { "signedAttributeError", "dap.signedAttributeError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AttributeError/signedAttributeError", HFILL }},
+        "dap.T_signedAttributeError", HFILL }},
     { &hf_dap_attributeError,
       { "attributeError", "dap.attributeError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AttributeError/signedAttributeError/attributeError", HFILL }},
+        "dap.AttributeErrorData", HFILL }},
     { &hf_dap_name_error_problem,
       { "problem", "dap.problem",
         FT_INT32, BASE_DEC, VALS(dap_NameProblem_vals), 0,
-        "NameErrorData/problem", HFILL }},
+        "dap.NameProblem", HFILL }},
     { &hf_dap_matched_name,
       { "matched", "dap.matched",
         FT_UINT32, BASE_DEC, VALS(x509if_Name_vals), 0,
-        "NameErrorData/matched", HFILL }},
+        "dap.Name", HFILL }},
     { &hf_dap_unsignedNameError,
       { "unsignedNameError", "dap.unsignedNameError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "NameError/unsignedNameError", HFILL }},
+        "dap.NameErrorData", HFILL }},
     { &hf_dap_signedNameError,
       { "signedNameError", "dap.signedNameError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "NameError/signedNameError", HFILL }},
+        "dap.T_signedNameError", HFILL }},
     { &hf_dap_nameError,
       { "nameError", "dap.nameError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "NameError/signedNameError/nameError", HFILL }},
+        "dap.NameErrorData", HFILL }},
     { &hf_dap_candidate,
       { "candidate", "dap.candidate",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ReferralData/candidate", HFILL }},
+        "dsp.ContinuationReference", HFILL }},
     { &hf_dap_unsignedReferral,
       { "unsignedReferral", "dap.unsignedReferral",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Referral/unsignedReferral", HFILL }},
+        "dap.ReferralData", HFILL }},
     { &hf_dap_signedReferral,
       { "signedReferral", "dap.signedReferral",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Referral/signedReferral", HFILL }},
+        "dap.T_signedReferral", HFILL }},
     { &hf_dap_referral,
       { "referral", "dap.referral",
         FT_NONE, BASE_NONE, NULL, 0,
-        "Referral/signedReferral/referral", HFILL }},
+        "dap.ReferralData", HFILL }},
     { &hf_dap_security_error_problem,
       { "problem", "dap.problem",
         FT_INT32, BASE_DEC, VALS(dap_SecurityProblem_vals), 0,
-        "SecurityErrorData/problem", HFILL }},
+        "dap.SecurityProblem", HFILL }},
     { &hf_dap_spkmInfo,
       { "spkmInfo", "dap.spkmInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SecurityErrorData/spkmInfo", HFILL }},
+        "dap.T_spkmInfo", HFILL }},
     { &hf_dap_unsignedSecurityError,
       { "unsignedSecurityError", "dap.unsignedSecurityError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SecurityError/unsignedSecurityError", HFILL }},
+        "dap.SecurityErrorData", HFILL }},
     { &hf_dap_signedSecurityError,
       { "signedSecurityError", "dap.signedSecurityError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SecurityError/signedSecurityError", HFILL }},
+        "dap.T_signedSecurityError", HFILL }},
     { &hf_dap_securityErrorData,
       { "securityError", "dap.securityError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SecurityError/signedSecurityError/securityError", HFILL }},
+        "dap.SecurityErrorData", HFILL }},
     { &hf_dap_service_error_problem,
       { "problem", "dap.problem",
         FT_INT32, BASE_DEC, VALS(dap_ServiceProblem_vals), 0,
-        "ServiceErrorData/problem", HFILL }},
+        "dap.ServiceProblem", HFILL }},
     { &hf_dap_unsignedServiceError,
       { "unsignedServiceError", "dap.unsignedServiceError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ServiceError/unsignedServiceError", HFILL }},
+        "dap.ServiceErrorData", HFILL }},
     { &hf_dap_signedServiceError,
       { "signedServiceError", "dap.signedServiceError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ServiceError/signedServiceError", HFILL }},
+        "dap.T_signedServiceError", HFILL }},
     { &hf_dap_serviceError,
       { "serviceError", "dap.serviceError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ServiceError/signedServiceError/serviceError", HFILL }},
+        "dap.ServiceErrorData", HFILL }},
     { &hf_dap_update_error_problem,
       { "problem", "dap.problem",
         FT_INT32, BASE_DEC, VALS(dap_UpdateProblem_vals), 0,
-        "UpdateErrorData/problem", HFILL }},
+        "dap.UpdateProblem", HFILL }},
     { &hf_dap_attributeInfo,
       { "attributeInfo", "dap.attributeInfo",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "UpdateErrorData/attributeInfo", HFILL }},
+        "dap.T_attributeInfo", HFILL }},
     { &hf_dap_attributeInfo_item,
       { "Item", "dap.attributeInfo_item",
         FT_UINT32, BASE_DEC, VALS(dap_T_attributeInfo_item_vals), 0,
-        "UpdateErrorData/attributeInfo/_item", HFILL }},
+        "dap.T_attributeInfo_item", HFILL }},
     { &hf_dap_unsignedUpdateError,
       { "unsignedUpdateError", "dap.unsignedUpdateError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "UpdateError/unsignedUpdateError", HFILL }},
+        "dap.UpdateErrorData", HFILL }},
     { &hf_dap_signedUpdateError,
       { "signedUpdateError", "dap.signedUpdateError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "UpdateError/signedUpdateError", HFILL }},
+        "dap.T_signedUpdateError", HFILL }},
     { &hf_dap_updateError,
       { "updateError", "dap.updateError",
         FT_NONE, BASE_NONE, NULL, 0,
-        "UpdateError/signedUpdateError/updateError", HFILL }},
+        "dap.UpdateErrorData", HFILL }},
     { &hf_dap_ServiceControlOptions_preferChaining,
       { "preferChaining", "dap.preferChaining",
         FT_BOOLEAN, 8, NULL, 0x80,
index 1ec388a90826ceeeb890814a31ca9dbb1473576e..eb9444e60448227061d948c84ca3d0b180d0a3c0 100644 (file)
@@ -1954,431 +1954,431 @@ void proto_register_disp(void) {
     { &hf_disp_EstablishParameter_PDU,
       { "EstablishParameter", "disp.EstablishParameter",
         FT_NONE, BASE_NONE, NULL, 0,
-        "EstablishParameter", HFILL }},
+        "disp.EstablishParameter", HFILL }},
     { &hf_disp_ModificationParameter_PDU,
       { "ModificationParameter", "disp.ModificationParameter",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModificationParameter", HFILL }},
+        "disp.ModificationParameter", HFILL }},
     { &hf_disp_ShadowingAgreementInfo_PDU,
       { "ShadowingAgreementInfo", "disp.ShadowingAgreementInfo",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ShadowingAgreementInfo", HFILL }},
+        "disp.ShadowingAgreementInfo", HFILL }},
     { &hf_disp_modifiedSecondaryShadows,
       { "secondaryShadows", "disp.secondaryShadows",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ModificationParameter/secondaryShadows", HFILL }},
+        "disp.SET_OF_SupplierAndConsumers", HFILL }},
     { &hf_disp_modifiedSecondaryShadows_item,
       { "Item", "disp.secondaryShadows_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ModificationParameter/secondaryShadows/_item", HFILL }},
+        "dop.SupplierAndConsumers", HFILL }},
     { &hf_disp_shadowSubject,
       { "shadowSubject", "disp.shadowSubject",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ShadowingAgreementInfo/shadowSubject", HFILL }},
+        "disp.UnitOfReplication", HFILL }},
     { &hf_disp_updateMode,
       { "updateMode", "disp.updateMode",
         FT_UINT32, BASE_DEC, VALS(disp_UpdateMode_vals), 0,
-        "ShadowingAgreementInfo/updateMode", HFILL }},
+        "disp.UpdateMode", HFILL }},
     { &hf_disp_master,
       { "master", "disp.master",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ShadowingAgreementInfo/master", HFILL }},
+        "dsp.AccessPoint", HFILL }},
     { &hf_disp_secondaryShadows,
       { "secondaryShadows", "disp.secondaryShadows",
         FT_BOOLEAN, 8, NULL, 0,
-        "ShadowingAgreementInfo/secondaryShadows", HFILL }},
+        "disp.BOOLEAN", HFILL }},
     { &hf_disp_area,
       { "area", "disp.area",
         FT_NONE, BASE_NONE, NULL, 0,
-        "UnitOfReplication/area", HFILL }},
+        "disp.AreaSpecification", HFILL }},
     { &hf_disp_replication_attributes,
       { "attributes", "disp.attributes",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "UnitOfReplication/attributes", HFILL }},
+        "disp.AttributeSelection", HFILL }},
     { &hf_disp_knowledge,
       { "knowledge", "disp.knowledge",
         FT_NONE, BASE_NONE, NULL, 0,
-        "UnitOfReplication/knowledge", HFILL }},
+        "disp.Knowledge", HFILL }},
     { &hf_disp_subordinates,
       { "subordinates", "disp.subordinates",
         FT_BOOLEAN, 8, NULL, 0,
-        "UnitOfReplication/subordinates", HFILL }},
+        "disp.BOOLEAN", HFILL }},
     { &hf_disp_contextSelection,
       { "contextSelection", "disp.contextSelection",
         FT_UINT32, BASE_DEC, VALS(dap_ContextSelection_vals), 0,
-        "UnitOfReplication/contextSelection", HFILL }},
+        "dap.ContextSelection", HFILL }},
     { &hf_disp_supplyContexts,
       { "supplyContexts", "disp.supplyContexts",
         FT_UINT32, BASE_DEC, VALS(disp_T_supplyContexts_vals), 0,
-        "UnitOfReplication/supplyContexts", HFILL }},
+        "disp.T_supplyContexts", HFILL }},
     { &hf_disp_allContexts,
       { "allContexts", "disp.allContexts",
         FT_NONE, BASE_NONE, NULL, 0,
-        "UnitOfReplication/supplyContexts/allContexts", HFILL }},
+        "disp.NULL", HFILL }},
     { &hf_disp_selectedContexts,
       { "selectedContexts", "disp.selectedContexts",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "UnitOfReplication/supplyContexts/selectedContexts", HFILL }},
+        "disp.T_selectedContexts", HFILL }},
     { &hf_disp_selectedContexts_item,
       { "Item", "disp.selectedContexts_item",
         FT_OID, BASE_NONE, NULL, 0,
-        "UnitOfReplication/supplyContexts/selectedContexts/_item", HFILL }},
+        "disp.OBJECT_IDENTIFIER", HFILL }},
     { &hf_disp_contextPrefix,
       { "contextPrefix", "disp.contextPrefix",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "AreaSpecification/contextPrefix", HFILL }},
+        "x509if.DistinguishedName", HFILL }},
     { &hf_disp_replicationArea,
       { "replicationArea", "disp.replicationArea",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AreaSpecification/replicationArea", HFILL }},
+        "x509if.SubtreeSpecification", HFILL }},
     { &hf_disp_knowledgeType,
       { "knowledgeType", "disp.knowledgeType",
         FT_UINT32, BASE_DEC, VALS(disp_T_knowledgeType_vals), 0,
-        "Knowledge/knowledgeType", HFILL }},
+        "disp.T_knowledgeType", HFILL }},
     { &hf_disp_extendedKnowledge,
       { "extendedKnowledge", "disp.extendedKnowledge",
         FT_BOOLEAN, 8, NULL, 0,
-        "Knowledge/extendedKnowledge", HFILL }},
+        "disp.BOOLEAN", HFILL }},
     { &hf_disp_AttributeSelection_item,
       { "Item", "disp.AttributeSelection_item",
         FT_NONE, BASE_NONE, NULL, 0,
-        "AttributeSelection/_item", HFILL }},
+        "disp.ClassAttributeSelection", HFILL }},
     { &hf_disp_class,
       { "class", "disp.class",
         FT_OID, BASE_NONE, NULL, 0,
-        "ClassAttributeSelection/class", HFILL }},
+        "disp.OBJECT_IDENTIFIER", HFILL }},
     { &hf_disp_classAttributes,
       { "classAttributes", "disp.classAttributes",
         FT_UINT32, BASE_DEC, VALS(disp_ClassAttributes_vals), 0,
-        "ClassAttributeSelection/classAttributes", HFILL }},
+        "disp.ClassAttributes", HFILL }},
     { &hf_disp_allAttributes,
       { "allAttributes", "disp.allAttributes",
         FT_NONE, BASE_NONE, NULL, 0,
-        "ClassAttributes/allAttributes", HFILL }},
+        "disp.NULL", HFILL }},
     { &hf_disp_include,
       { "include", "disp.include",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ClassAttributes/include", HFILL }},
+        "disp.AttributeTypes", HFILL }},
     { &hf_disp_exclude,
       { "exclude", "disp.exclude",
         FT_UINT32, BASE_DEC, NULL, 0,
-        "ClassAttributes/exclude", HFILL }},
+        "disp.AttributeTypes", HFILL }},
     { &hf_disp_AttributeTypes_item,
       { "Item", "disp.AttributeTypes_item",
         FT_OID, BASE_NONE, NULL, 0,
-        "AttributeTypes/_item", HFILL }},
+        "x509if.AttributeType", HFILL }},
     { &hf_disp_supplierInitiated,
       { "supplierInitiated", "disp.supplierInitiated",
         FT_UINT32, BASE_DEC, VALS(disp_SupplierUpdateMode_vals), 0,
-        "UpdateMode/supplierInitiated", HFILL }},
+        "disp.SupplierUpdateMode", HFILL }},
     { &hf_disp_consumerInitiated,
       { "consumerInitiated", "disp.consumerInitiated",
         FT_NONE, BASE_NONE, NULL, 0,
-        "UpdateMode/consumerInitiated", HFILL }},
+        "disp.ConsumerUpdateMode", HFILL }},
     { &hf_disp_onChange,
       { "onChange", "disp.onChange",
         FT_BOOLEAN, 8, NULL, 0,
-        "SupplierUpdateMode/onChange", HFILL }},
+        "disp.BOOLEAN", HFILL }},
     { &hf_disp_scheduled,
       { "scheduled", "disp.scheduled",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SupplierUpdateMode/scheduled", HFILL }},
+        "disp.SchedulingParameters", HFILL }},
     { &hf_disp_periodic,
       { "periodic", "disp.periodic",
         FT_NONE, BASE_NONE, NULL, 0,
-        "SchedulingParameters/periodic", HFILL }},
+        "disp.PeriodicStrategy", HFILL }},
     { &hf_disp_othertimes,
       { "othertimes", "disp.othertimes",
         FT_BOOLEAN, 8, NULL, 0,
-        "SchedulingParameters/othertimes", HFILL }},
+        "disp.BOOLEAN", HFILL }},
     { &hf_disp_beginTime,
       { "beginTime", "disp.beginTime",
         FT_STRING, BASE_NONE, NULL, 0,
-        "PeriodicStrategy/beginTime", HFILL }},
+        "disp.Time", HFILL }},
     { &hf_disp_windowSize,
       { "windowSize", "disp.windowSize",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PeriodicStrategy/windowSize", HFILL }},
+        "disp.INTEGER", HFILL }},
     { &hf_disp_updateInterval,
       { "updateInterval", "disp.updateInterval",
         FT_INT32, BASE_DEC, NULL, 0,
-        "PeriodicStrategy/updateInterval", HFILL }},
+        "disp.INTEGER", HFILL }},
     { &hf_disp_agreementID,
       { "agreementID", "disp.agreementID",
         FT_NONE, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "disp.AgreementID", HFILL }},
     { &hf_disp_lastUpdate,
       { "lastUpdate", "disp.lastUpdate",
         FT_STRING, BASE_NONE, NULL, 0,
-        "", HFILL }},
+        "disp.Time", HFILL }},
     { &hf_disp_updateStrategy,
       { "updateStrategy", "disp.updateStrategy",
         FT_UINT32, BASE_DEC, VALS(disp_T_updateStrategy_vals), 0,
-        "CoordinateShadowUpdateArgumentData/updateStrategy", HFILL }},
+        "disp.T_updateStrategy", HFILL }},
     { &hf_disp_standardUpdate,
       { "standard", "disp.standard",
         FT_UINT32, BASE_DEC, VALS(disp_StandardUpdate_vals), 0,
-        "CoordinateShadowUpdateArgumentData/