ASN.1 dissectors regenerated with new asn2wrs to get updated field blurb

git-svn-id: http://anonsvn.wireshark.org/wireshark/trunk@18921 f5534014-38df-0310-8fa8-9805f1628bb7

1 files changed, 98 insertions, 98 deletions

diff --git a/epan/dissectors/packet-cmp.c b/epan/dissectors/packet-cmp.c
index a262e08fa2..2a31b39393 100644
--- a/epan/dissectors/packet-cmp.c
+++ b/epan/dissectors/packet-cmp.c
@@ -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,