diff options
-rw-r--r-- | docbook/release-notes.asciidoc | 1 | ||||
-rw-r--r-- | epan/dissectors/CMakeLists.txt | 2 | ||||
-rw-r--r-- | epan/dissectors/asn1/CMakeLists.txt | 1 | ||||
-rw-r--r-- | epan/dissectors/asn1/z3950/CMakeLists.txt | 40 | ||||
-rw-r--r-- | epan/dissectors/asn1/z3950/packet-z3950-template.c | 1639 | ||||
-rw-r--r-- | epan/dissectors/asn1/z3950/z3950-externals.asn | 1679 | ||||
-rw-r--r-- | epan/dissectors/asn1/z3950/z3950-oclc.asn | 14 | ||||
-rw-r--r-- | epan/dissectors/asn1/z3950/z3950.asn | 807 | ||||
-rw-r--r-- | epan/dissectors/asn1/z3950/z3950.cnf | 278 | ||||
-rw-r--r-- | epan/dissectors/packet-z3950.c | 13065 | ||||
-rw-r--r-- | epan/dissectors/packet-z3950.h | 24 | ||||
-rw-r--r-- | wsutil/str_util.c | 2 | ||||
-rw-r--r-- | wsutil/str_util.h | 2 |
13 files changed, 17552 insertions, 2 deletions
diff --git a/docbook/release-notes.asciidoc b/docbook/release-notes.asciidoc index 271326448d..68a8844ced 100644 --- a/docbook/release-notes.asciidoc +++ b/docbook/release-notes.asciidoc @@ -130,6 +130,7 @@ TPM 2.0 Ubiquiti Discovery Protocol (UBDP) WireGuard XnAP (5G) +Z39.50 Information Retrieval Protocol PCOM protocol -- diff --git a/epan/dissectors/CMakeLists.txt b/epan/dissectors/CMakeLists.txt index bce4d27062..a12eab352b 100644 --- a/epan/dissectors/CMakeLists.txt +++ b/epan/dissectors/CMakeLists.txt @@ -608,6 +608,7 @@ set(DISSECTOR_PUBLIC_HEADERS packet-yppasswd.h packet-ypserv.h packet-ypxfr.h + packet-z3950.h packet-zbee.h packet-zbee-aps.h packet-zbee-nwk.h @@ -1880,6 +1881,7 @@ set(DISSECTOR_SRC ${CMAKE_CURRENT_SOURCE_DIR}/packet-yppasswd.c ${CMAKE_CURRENT_SOURCE_DIR}/packet-ypserv.c ${CMAKE_CURRENT_SOURCE_DIR}/packet-ypxfr.c + ${CMAKE_CURRENT_SOURCE_DIR}/packet-z3950.c ${CMAKE_CURRENT_SOURCE_DIR}/packet-zbee-aps.c ${CMAKE_CURRENT_SOURCE_DIR}/packet-zbee-nwk.c ${CMAKE_CURRENT_SOURCE_DIR}/packet-zbee-nwk-gp.c diff --git a/epan/dissectors/asn1/CMakeLists.txt b/epan/dissectors/asn1/CMakeLists.txt index 05f6a362b0..5874ddfdcc 100644 --- a/epan/dissectors/asn1/CMakeLists.txt +++ b/epan/dissectors/asn1/CMakeLists.txt @@ -128,6 +128,7 @@ set(ASN1_SRC_DIRS x509if x509sat xnap + z3950 ${CUSTOM_ASN1_SRC_DIR} ) diff --git a/epan/dissectors/asn1/z3950/CMakeLists.txt b/epan/dissectors/asn1/z3950/CMakeLists.txt new file mode 100644 index 0000000000..d2d5af9cbf --- /dev/null +++ b/epan/dissectors/asn1/z3950/CMakeLists.txt @@ -0,0 +1,40 @@ +# CMakeLists.txt +# +# Wireshark - Network traffic analyzer +# By Gerald Combs <gerald@wireshark.org> +# Copyright 1998 Gerald Combs +# +# SPDX-License-Identifier: GPL-2.0-or-later +# + +set( PROTOCOL_NAME z3950 ) + +set( PROTO_OPT ) + +set( EXPORT_FILES + ${PROTOCOL_NAME}-exp.cnf +) + +set( EXT_ASN_FILE_LIST +) + +set( ASN_FILE_LIST + z3950.asn + z3950-oclc.asn + z3950-externals.asn +) + +set( EXTRA_DIST + ${ASN_FILE_LIST} + packet-${PROTOCOL_NAME}-template.c + ${PROTOCOL_NAME}.cnf +) + +set( SRC_FILES + ${EXTRA_DIST} + ${EXT_ASN_FILE_LIST} +) + +set( A2W_FLAGS -b ) + +ASN2WRS() diff --git a/epan/dissectors/asn1/z3950/packet-z3950-template.c b/epan/dissectors/asn1/z3950/packet-z3950-template.c new file mode 100644 index 0000000000..73ff59161d --- /dev/null +++ b/epan/dissectors/asn1/z3950/packet-z3950-template.c @@ -0,0 +1,1639 @@ +/* packet-z3950.c + * Routines for dissection of the NISO Z39.50 Information Retrieval protocol + * Also contains a dissector for the MARC Machine Readable Cataloging file + * format. The general format is specified by ISO 2709 and the specific + * instance is MARC21. + * + * Copyright 2018, Craig Jackson <cejackson51@gmail.com> + * + * Wireshark - Network traffic analyzer + * By Gerald Combs <gerald@wireshark.org> + * Copyright 1998 Gerald Combs + * + * SPDX-License-Identifier: GPL-2.0-or-later + * + * References: + * ISO 2709: https://www.iso.org/standard/41319.html + * MARC21: http://www.loc.gov/marc/bibliographic/ + * Z39.50 Maintenance Agency: http://www.loc.gov/z3950/agency/ + * Z39.50 2003 standard: http://www.loc.gov/z3950/agency/Z39-50-2003.pdf + * Z39.50 1995 ASN.1: https://www.loc.gov/z3950/agency/asn1.html + * Registered Z39.50 Object Identifiers: + * http://www.loc.gov/z3950/agency/defns/oids.html + * Bib-1 Attribute Set: https://www.loc.gov/z3950/agency/defns/bib1.html + * Bib-1 Diagnostics: https://www.loc.gov/z3950/agency/defns/bib1diag.html + * RFC for Z39.50 over TCP/IP: https://tools.ietf.org/html/rfc1729 + * + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <glib.h> +#include <epan/packet.h> +#include <epan/conversation.h> +#include <epan/exceptions.h> +#include <epan/expert.h> +#include <epan/oids.h> +#include <epan/proto_data.h> +#include <wsutil/str_util.h> + +#include <stdio.h> +#include <string.h> + +#include "packet-ber.h" +#include "packet-tcp.h" + +typedef struct z3950_atinfo_t { + gint atsetidx; + gint attype; +} z3950_atinfo_t; + +typedef struct z3950_diaginfo_t { + gint diagsetidx; + gint diagcondition; +} z3950_diaginfo_t; + +#define PNAME "Z39.50 Protocol" +#define PSNAME "Z39.50" +#define PFNAME "z3950" +#define Z3950_PORT 210 /* UDP port */ + +/* Known attribute set ids */ +#define Z3950_ATSET_BIB1_OID "1.2.840.10003.3.1" + +/* Known diagnostic set ids */ +#define Z3950_DIAGSET_BIB1_OID "1.2.840.10003.4.1" + +/* Known record syntax ids */ +#define Z3950_RECORDSYNTAX_MARC21_OID "1.2.840.10003.5.10" + +/* Indexes of known attribute set ids */ +#define Z3950_ATSET_UNKNOWN 0 +#define Z3950_ATSET_BIB1 1 + +/* bib-1 Attribute Types */ +#define Z3950_BIB1_AT_USE 1 +#define Z3950_BIB1_AT_RELATION 2 +#define Z3950_BIB1_AT_POSITION 3 +#define Z3950_BIB1_AT_STRUCTURE 4 +#define Z3950_BIB1_AT_TRUNCATION 5 +#define Z3950_BIB1_AT_COMPLETENESS 6 + +/* Indexes of known diagnostic set ids */ +#define Z3950_DIAGSET_UNKNOWN 0 +#define Z3950_DIAGSET_BIB1 1 + +/* Per-packet data keys */ +#define Z3950_ATINFO_KEY 1 +#define Z3950_DIAGSET_KEY 2 + +/* MARC defines */ +#define MARC_SUBFIELD_INDICATOR '\x1f' +#define MARC_LEADER_LENGTH 24 +#define MARC_CHAR_UNINITIALIZED 256 + +#define marc_isdigit(x) (((x) >='0') && ((x) <= '9')) +#define marc_char_to_int(x) ((x) - '0') + +typedef struct marc_directory_entry { + guint32 tag; + guint32 length; + guint32 starting_character; +} marc_directory_entry; + +static dissector_handle_t z3950_handle=NULL; + +void proto_reg_handoff_z3950(void); +void proto_register_z3950(void); + +/* Initialize the protocol and registered fields */ +static int proto_z3950 = -1; +static int global_z3950_port = Z3950_PORT; +static gboolean z3950_desegment = TRUE; + +static const value_string z3950_bib1_att_types[] = { + { Z3950_BIB1_AT_USE, "Use" }, + { Z3950_BIB1_AT_RELATION, "Relation" }, + { Z3950_BIB1_AT_POSITION, "Position" }, + { Z3950_BIB1_AT_STRUCTURE, "Structure" }, + { Z3950_BIB1_AT_TRUNCATION, "Truncation" }, + { Z3950_BIB1_AT_COMPLETENESS, "Completeness"}, + { 0, NULL} +}; + +static const value_string z3950_bib1_at_use[] = { + { 1, "Personal name" }, + { 2, "Corporate name" }, + { 3, "Conference name" }, + { 4, "Title" }, + { 5, "Title series" }, + { 6, "Title uniform" }, + { 7, "ISBN" }, + { 8, "ISSN" }, + { 9, "LC card number" }, + { 10, "BNB card number" }, + { 11, "BGF card number" }, + { 12, "Local number" }, + { 13, "Dewey classification" }, + { 14, "UDC classification" }, + { 15, "Bliss classification" }, + { 16, "LC call number" }, + { 17, "NLM call number" }, + { 18, "NAL call number" }, + { 19, "MOS call number" }, + { 20, "Local classification" }, + { 21, "Subject heading" }, + { 22, "Subject Rameau" }, + { 23, "BDI index subject" }, + { 24, "INSPEC subject" }, + { 25, "MESH subject" }, + { 26, "PA subject" }, + { 27, "LC subject heading" }, + { 28, "RVM subject heading" }, + { 29, "Local subject index" }, + { 30, "Date" }, + { 31, "Date of publication" }, + { 32, "Date of acquisition" }, + { 33, "Title key" }, + { 34, "Title collective" }, + { 35, "Title parallel" }, + { 36, "Title cover" }, + { 37, "Title added title pagw" }, + { 38, "Title caption" }, + { 39, "Title running" }, + { 40, "Title spine" }, + { 41, "Title other variant" }, + { 42, "Title former" }, + { 43, "Title abbreviated" }, + { 44, "Title expanded" }, + { 45, "Subject precis" }, + { 46, "Subject rswk" }, + { 47, "Subject subdivision" }, + { 48, "No. nat'l biblio." }, + { 49, "No. legal deposit" }, + { 50, "No. govt pub." }, + { 51, "No. music publisher" }, + { 52, "Number db" }, + { 53, "Number local call" }, + { 54, "Code-language" }, + { 55, "Code-geographic area" }, + { 56, "Code-institution" }, + { 57, "Name and title *" }, + { 58, "Name geographic" }, + { 59, "Place publication" }, + { 60, "CODEN" }, + { 61, "Microform generation" }, + { 62, "Abstract" }, + { 63, "Note" }, + { 1000, "Author-title" }, + { 1001, "Record type" }, + { 1002, "Name" }, + { 1003, "Author" }, + { 1004, "Author-name personal" }, + { 1005, "Author-name corporate" }, + { 1006, "Author-name conference" }, + { 1007, "Identifier-standard" }, + { 1008, "Subject-LC children's" }, + { 1009, "Subject name-personal" }, + { 1010, "Body of text" }, + { 1011, "Date/time added to db" }, + { 1012, "Date/time last modified" }, + { 1013, "Authority/format id" }, + { 1014, "Concept-text" }, + { 1015, "Concept-reference" }, + { 1016, "Any" }, + { 1017, "Server-choice" }, + { 1018, "Publisher" }, + { 1019, "Record-source" }, + { 1020, "Editor" }, + { 1021, "Bib-level" }, + { 1022, "Geographic class" }, + { 1023, "Indexed-by" }, + { 1024, "Map-scale" }, + { 1025, "Music-key" }, + { 1026, "Related-periodical" }, + { 1027, "Report-number" }, + { 1028, "Stock-number" }, + { 1030, "Thematic-number" }, + { 1031, "Material-type" }, + { 1032, "Doc-id" }, + { 1033, "Host-item" }, + { 1034, "Content-type" }, + { 1035, "Anywhere" }, + { 1036, "Author-Title-Subject" }, + { 1037, "Serial Item and Contribution Identifer (SICI)" }, + { 1038, "Abstract-language" }, + { 1039, "Application-kind" }, + { 1040, "Classification" }, + { 1041, "Classification-basic" }, + { 1042, "Classification-local-record" }, + { 1043, "Enzyme" }, + { 1044, "Possessing-institution" }, + { 1045, "Record-linking" }, + { 1046, "Record-status" }, + { 1047, "Treatment" }, + { 1048, "Control-number-GKD" }, + { 1049, "Control-number-linking" }, + { 1050, "Control-number-PND" }, + { 1051, "Control-number-SWD" }, + { 1052, "Control-number-ZDB" }, + { 1053, "Country-publication" }, + { 1054, "Date-conference" }, + { 1055, "Date-record-status" }, + { 1056, "Dissertation-information" }, + { 1057, "Meeting-organizer" }, + { 1058, "Note-availability" }, + { 1059, "Number-CAS-registry" }, + { 1060, "Number-document" }, + { 1061, "Number-local-accounting" }, + { 1062, "Number-local-acquisition" }, + { 1063, "Number-local-call-copy-specific" }, + { 1064, "Number-of-reference" }, + { 1065, "Number-norm" }, + { 1066, "Number-volume" }, + { 1067, "Place-conference (meeting location)" }, + { 1068, "Reference (references and footnotes)" }, + { 1069, "Referenced-journal" }, + { 1070, "Section-code" }, + { 1071, "Section-heading" }, + { 1072, "Subject-GOO" }, + { 1073, "Subject-name-conference" }, + { 1074, "Subject-name-corporate" }, + { 1075, "Subject-genre/form" }, + { 1076, "Subject-name-geographical" }, + { 1077, "Subject-chronological" }, + { 1078, "Subject-title" }, + { 1079, "Subject-topical" }, + { 1080, "Subject-uncontrolled" }, + { 1081, "Terminology-chemical" }, + { 1082, "Title-translated" }, + { 1083, "Year-of-beginning" }, + { 1084, "Year-of-ending" }, + { 1085, "Subject-AGROVOC" }, + { 1086, "Subject-COMPASS" }, + { 1087, "Subject-EPT" }, + { 1088, "Subject-NAL" }, + { 1089, "Classification-BCM" }, + { 1090, "Classification-DB" }, + { 1091, "Identifier-ISRC" }, + { 1092, "Identifier-ISMN" }, + { 1093, "Identifier-ISRN" }, + { 1094, "Identifier-DOI" }, + { 1095, "Code-language-original" }, + { 1096, "Title-later" }, + { 1097, "DC-Title" }, + { 1098, "DC-Creator" }, + { 1099, "DC-Subject" }, + { 1100, "DC-Description" }, + { 1101, "DC-Publisher" }, + { 1102, "DC-Date" }, + { 1103, "DC-ResourceType" }, + { 1104, "DC-ResourceIdentifier" }, + { 1105, "DC-Language" }, + { 1106, "DC-OtherContributor" }, + { 1107, "DC-Format" }, + { 1108, "DC-Source" }, + { 1109, "DC-Relation" }, + { 1110, "DC-Coverage" }, + { 1111, "DC-RightsManagment" }, + { 1112, "GILS Controlled Subject Index" }, + { 1113, "GILS Subject Thesaurus" }, + { 1114, "GILS Index Terms -- Controlled" }, + { 1115, "GILS Controlled Term" }, + { 1116, "GILS Spacial Domain" }, + { 1117, "GILS Bounding Coordinates" }, + { 1118, "GILS West Bounding Coordinate" }, + { 1119, "GILS East Bounding Coordinate" }, + { 1120, "GILS North Bounding Coordinate" }, + { 1121, "GILS South Bounding Coordinate" }, + { 1122, "GILS Place" }, + { 1123, "GILS Place Keyword Thesaurus" }, + { 1124, "GILS Place Keyword" }, + { 1125, "GILS Time Period" }, + { 1126, "GILS Time Period Textual" }, + { 1127, "GILS Time Period Structured" }, + { 1128, "GILS Beginning Date" }, + { 1129, "GILS Ending Date" }, + { 1130, "GILS Availability" }, + { 1131, "GILS Distributor" }, + { 1132, "GILS Distributor Name" }, + { 1133, "GILS Distributor Organization" }, + { 1134, "GILS Distributor Street Address" }, + { 1135, "GILS Distributor City" }, + { 1136, "GILS Distributor State or Province" }, + { 1137, "GILS Distributor Zip or Postal Code" }, + { 1138, "GILS Distributor Country" }, + { 1139, "GILS Distributor Network Address" }, + { 1140, "GILS Distributor Hours of Service" }, + { 1141, "GILS Distributor Telephone" }, + { 1142, "GILS Distributor Fax" }, + { 1143, "GILS Resource Description" }, + { 1144, "GILS Order Process" }, + { 1145, "GILS Order Information" }, + { 1146, "GILS Cost" }, + { 1147, "GILS Cost Information" }, + { 1148, "GILS Technical Prerequisites" }, + { 1149, "GILS Available Time Period" }, + { 1150, "GILS Available Time Textual" }, + { 1151, "GILS Available Time Structured" }, + { 1152, "GILS Available Linkage" }, + { 1153, "GILS Linkage Type" }, + { 1154, "GILS Linkage" }, + { 1155, "GILS Sources of Data" }, + { 1156, "GILS Methodology" }, + { 1157, "GILS Access Constraints" }, + { 1158, "GILS General Access Constraints" }, + { 1159, "GILS Originator Dissemination Control" }, + { 1160, "GILS Security Classification Control" }, + { 1161, "GILS Use Constraints" }, + { 1162, "GILS Point of Contact" }, + { 1163, "GILS Contact Name" }, + { 1164, "GILS Contact Organization" }, + { 1165, "GILS Contact Street Address" }, + { 1166, "GILS Contact City" }, + { 1167, "GILS Contact State or Province" }, + { 1168, "GILS Contact Zip or Postal Code" }, + { 1169, "GILS Contact Country" }, + { 1170, "GILS Contact Network Address" }, + { 1171, "GILS Contact Hours of Service" }, + { 1172, "GILS Contact Telephone" }, + { 1173, "GILS Contact Fax" }, + { 1174, "GILS Supplemental Information" }, + { 1175, "GILS Purpose" }, + { 1176, "GILS Agency Program" }, + { 1177, "GILS Cross Reference" }, + { 1178, "GILS Cross Reference Title" }, + { 1179, "GILS Cross Reference Relationship" }, + { 1180, "GILS Cross Reference Linkage" }, + { 1181, "GILS Schedule Number" }, + { 1182, "GILS Original Control Identifier" }, + { 1183, "GILS Language of Record" }, + { 1184, "GILS Record Review Date" }, + { 1185, "Performer" }, + { 1186, "Performer-Individual" }, + { 1187, "Performer-Group" }, + { 1188, "Instrumentation" }, + { 1189, "Instrumentation-Original" }, + { 1190, "Instrumentation-Current" }, + { 1191, "Arrangement" }, + { 1192, "Arrangement-Original" }, + { 1193, "Arrangement-Current" }, + { 1194, "Musical Key-Original" }, + { 1195, "Musical Key-Current" }, + { 1196, "Date-Composition" }, + { 1197, "Date-Recording" }, + { 1198, "Place-Recording" }, + { 1199, "Country-Recording" }, + { 1200, "Number-ISWC" }, + { 1201, "Number-Matrix" }, + { 1202, "Number-Plate" }, + { 1203, "Classification-McColvin" }, + { 1204, "Duration" }, + { 1205, "Number-Copies" }, + { 1206, "Musical Theme" }, + { 1207, "Instruments - total number" }, + { 1208, "Instruments - distinct number" }, + { 1209, "Identifier - URN" }, + { 1210, "Sears Subject Heading" }, + { 1211, "OCLC Number" }, + { 1212, "NORZIG Composition" }, + { 1213, "NORZIG Intellectual level" }, + { 1214, "NORZIG EAN" }, + { 1215, "NORZIG NLC" }, + { 1216, "NORZIG CRCS" }, + { 1217, "NORZIG Nationality" }, + { 1218, "NORZIG Equinox" }, + { 1219, "NORZIG Compression" }, + { 1220, "NORZIG Format" }, + { 1221, "NORZIG Subject - occupation" }, + { 1222, "NORZIG Subject - function" }, + { 1223, "NORZIG Edition" }, + { 1224, "GPO Item Number" }, + { 1225, "Provider" }, + { 0, NULL} +}; + +static const value_string z3950_bib1_at_relation[] = { + { 1, "Less than" }, + { 2, "Less than or equal" }, + { 3, "Equal" }, + { 4, "Greater than or equal" }, + { 5, "Greater than" }, + { 6, "Not equal" }, + { 100, "Phonetic" }, + { 101, "Stem" }, + { 102, "Relevance" }, + { 103, "Always Matches" }, + { 0, NULL} +}; + +static const value_string z3950_bib1_at_position[] = { + { 1, "First in field" }, + { 2, "First in subfield" }, + { 3, "Any position in field" }, + { 0, NULL} +}; + +static const value_string z3950_bib1_at_structure[] = { + { 1, "Phrase" }, + { 2, "Word" }, + { 3, "Key" }, + { 4, "Year" }, + { 5, "Date (normalized)" }, + { 6, "Word list" }, + { 100, "Date (un-normalized)" }, + { 101, "Name (normalized)" }, + { 102, "Name (un-normalized)" }, + { 103, "Structure" }, + { 104, "Urx" }, + { 105, "Free-form-text" }, + { 106, "Document-text" }, + { 107, "Local" }, + { 108, "String" }, + { 109, "Numeric" }, + { 0, NULL} +}; + +static const value_string z3950_bib1_at_truncation[] = { + { 1, "Right truncation" }, + { 2, "Left truncation" }, + { 3, "Left and right truncation" }, + { 100, "Do not truncate" }, + { 101, "Process # in search term" }, + { 102, "regExpr-1" }, + { 103, "regExpr-2" }, + { 104, "Z39.58-1992 Character masking" }, + { 0, NULL} +}; + +static const value_string z3950_bib1_at_completeness[] = { + { 1, "Incomplete subfield" }, + { 2, "Complete subfield" }, + { 3, "Complete field" }, + { 0, NULL} +}; + +static const value_string z3950_bib1_diagconditions[] = { + { 1, "Permanent system error" }, + { 2, "Temporary system error" }, + { 3, "Unsupported search" }, + { 4, "Terms only exclusion (stop) words" }, + { 5, "Too many argument words" }, + { 6, "Too many boolean operators" }, + { 7, "Too many truncated words" }, + { 8, "Too many incomplete subfields" }, + { 9, "Truncated words too short" }, + { 10, "Invalid format for record number (search term)" }, + { 11, "Too many characters in search statement" }, + { 12, "Too many records retrieved" }, + { 13, "Present request out of range" }, + { 14, "System error in presenting records" }, + { 15, "Record no authorized to be sent intersystem" }, + { 16, "Record exceeds Preferred-message-size" }, + { 17, "Record exceeds Maximum-record-size" }, + { 18, "Result set not supported as a search term" }, + { 19, "Only single result set as search term supported" }, + { 20, "Only ANDing of a single result set as search term supported" }, + { 21, "Result set exists and replace indicator off" }, + { 22, "Result set naming not supported" }, + { 23, "Combination of specified databases not supported" }, + { 24, "Element set names not supported" }, + { 25, "Specified element set name not valid for specified database" }, + { 26, "Only a single element set name supported" }, + { 27, "Result set no longer exists - unilaterally deleted by target" }, + { 28, "Result set is in use" }, + { 29, "One of the specified databases is locked" }, + { 30, "Specified result set does not exist" }, + { 31, "Resources exhausted - no results available" }, + { 32, "Resources exhausted - unpredictable partial results available" }, + { 33, "Resources exhausted - valid subset of results available" }, + { 100, "Unspecified error" }, + { 101, "Access-control failure" }, + { 102, "Security challenge required but could not be issued - request terminated" }, + { 103, "Security challenge required but could not be issued - record not included" }, + { 104, "Security challenge failed - record not included" }, + { 105, "Terminated by negative continue response" }, + { 106, "No abstract syntaxes agreed to for this record" }, + { 107, "Query type not supported" }, + { 108, "Malformed query" }, + { 109, "Database unavailable" }, + { 110, "Operator unsupported" }, + { 111, "Too many databases specified" }, + { 112, "Too many result sets created" }, + { 113, "Unsupported attribute type" }, + { 114, "Unsupported Use attribute" }, + { 115, "Unsupported value for Use attribute" }, + { 116, "Use attribute required but not supplied" }, + { 117, "Unsupported Relation attribute" }, + { 118, "Unsupported Structure attribute" }, + { 119, "Unsupported Position attribute" }, + { 120, "Unsupported Truncation attribute" }, + { 121, "Unsupported Attribute Set" }, + { 122, "Unsupported Completeness attribute" }, + { 123, "Unsupported attribute combination" }, + { 124, "Unsupported coded value for term" }, + { 125, "Malformed search term" }, + { 126, "Illegal term value for attribute" }, + { 127, "Unparsable format for un-normalized value" }, + { 128, "Illegal result set name" }, + { 129, "Proximity search of sets not supported" }, + { 130, "Illegal result set in proximity search" }, + { 131, "Unsupported proximity relation" }, + { 132, "Unsupported proximity unit code" }, + { 201, "Proximity not supported with this attribute combination" }, + { 202, "Unsupported distance for proximity" }, + { 203, "Ordered flag not supported for proximity" }, + { 205, "Only zero step size supported for Scan" }, + { 206, "Specified step size not supported for Scan" }, + { 207, "Cannot sort according to sequence" }, + { 208, "No result set name supplied on Sort" }, + { 209, "Generic sort not supported (database-specific sort only supported)" }, + { 210, "Database specific sort not supported" }, + { 211, "Too many sort keys" }, + { 212, "Duplicate sort keys" }, + { 213, "Unsupported missing data action" }, + { 214, "Illegal sort relation" }, + { 215, "Illegal case value" }, + { 216, "Illegal missing data action" }, + { 217, "Segmentation: Cannot guarantee records will fit in specified segments" }, + { 218, "ES: Package name already in use" }, + { 219, "ES: no such package, on modify/delete" }, + { 220, "ES: quota exceeded" }, + { 221, "ES: extended service type not supported" }, + { 222, "ES: permission denied on ES - id not authorized" }, + { 223, "ES: permission denied on ES - cannot modify or delete" }, + { 224, "ES: immediate execution failed" }, + { 225, "ES: immediate execution not supported for this service" }, + { 226, "ES: immediate execution not supported for these parameters" }, + { 227, "No data available in requested record syntax" }, + { 228, "Scan: malformed scan" }, + { 229, "Term type not supported" }, + { 230, "Sort: too many input results" }, + { 231, "Sort: incompatible record formats" }, + { 232, "Scan: term list not supported" }, + { 233, "Scan: unsupported value of position-in-response" }, + { 234, "Too many index terms processed" }, + { 235, "Database does not exist" }, + { 236, "Access to specified database denied" }, + { 237, "Sort: illegal sort" }, + { 238, "Record not available in requested syntax" }, + { 239, "Record syntax not supported" }, + { 240, "Scan: Resources exhausted looking for satisfying terms" }, + { 241, "Scan: Beginning or end of term list" }, + { 242, "Segmentation: max-segment-size too small to segment record" }, + { 243, "Present: additional-ranges parameter not supported" }, + { 244, "Present: comp-spec parameter not supported" }, + { 245, "Type-1 query: restriction ('resultAttr') operand not supported" }, + { 246, "Type-1 query: 'complex' attributeValue not supported" }, + { 247, "Type-1 query: 'attributeSet' as part of AttributeElement not supported" }, + { 1001, "Malformed APDU" }, + { 1002, "ES: EXTERNAL form of Item Order request not supported" }, + { 1003, "ES: Result set item form of Item Order request not supported" }, + { 1004, "ES: Extended services not supported unless access control is in effect" }, + { 1005, "Response records in Search response not supported" }, + { 1006, "Response records in Search response not possible for specified database (or database combination)" }, + { 1007, "No Explain server. Addinfo: pointers to servers that have a surrogate Explain database for this server" }, + { 1008, "ES: missing mandatory parameter for specified function. Addinfo: parameter" }, + { 1009, "ES: Item Order, unsupported OID in itemRequest. Addinfo: OID" }, + { 1010, "Init/AC: Bad Userid" }, + { 1011, "Init/AC: Bad Userid and/or Password" }, + { 1012, "Init/AC: No searches remaining (pre-purchased searches exhausted)" }, + { 1013, "Init/AC: Incorrect interface type (specified id valid only when used with a particular access method or client)" }, + { 1014, "Init/AC: Authentication System error" }, + { 1015, "Init/AC: Maximum number of simultaneous sessions for Userid" }, + { 1016, "Init/AC: Blocked network address" }, + { 1017, "Init/AC: No databases available for specified userId" }, + { 1018, "Init/AC: System temporarily out of resources" }, + { 1019, "Init/AC: System not available due to maintenance" }, + { 1020, "Init/AC: System temporarily unavailable (Addinfo: when it's expected back up)" }, + { 1021, "Init/AC: Account has expired" }, + { 1022, "Init/AC: Password has expired so a new one must be supplied" }, + { 1023, "Init/AC: Password has been changed by an administrator so a new one must be supplied" }, + { 1024, "Unsupported Attribute" }, + { 1025, "Service not supported for this database" }, + { 1026, "Record cannot be opened because it is locked" }, + { 1027, "SQL error" }, + { 1028, "Record deleted" }, + { 1029, "Scan: too many terms requested. Addinfo: max terms supported" }, + { 1040, "ES: Invalid function" }, + { 1041, "ES: Error in retention time" }, + { 1042, "ES: Permissions data not understood" }, + { 1043, "ES: Invalid OID for task specific parameters" }, + { 1044, "ES: Invalid action" }, + { 1045, "ES: Unknown schema" }, + { 1046, "ES: Too many records in package" }, + { 1047, "ES: Invalid wait action" }, + { 1048, "ES: Cannot create task package -- exceeds maximum permissable size" }, + { 1049, "ES: Cannot return task package -- exceeds maximum permissable size" }, + { 1050, "ES: Extended services request too large" }, + { 1051, "Scan: Attribute set id required -- not supplied" }, + { 1052, "ES: Cannot process task package record -- exceeds maximum permissible record size for ES" }, + { 1053, "ES: Cannot return task package record -- exceeds maximum permissible record size for ES response" }, + { 1054, "Init: Required negotiation record not included" }, + { 1055, "Init: negotiation option required" }, + { 1056, "Attribute not supported for database" }, + { 1057, "ES: Unsupported value of task package parameter" }, + { 1058, "Duplicate Detection: Cannot dedup on requested record portion" }, + { 1059, "Duplicate Detection: Requested detection criterion not supported" }, + { 1060, "Duplicate Detection: Requested level of match not supported" }, + { 1061, "Duplicate Detection: Requested regular expression not supported" }, + { 1062, "Duplicate Detection: Cannot do clustering" }, + { 1063, "Duplicate Detection: Retention criterion not supported" }, + { 1064, "Duplicate Detection: Requested number (or percentage) of entries for retention too large" }, + { 1065, "Duplicate Detection: Requested sort criterion not supported" }, + { 1066, "CompSpec: Unknown schema, or schema not supported." }, + { 1067, "Encapsulation: Encapsulated sequence of PDUs not supported" }, + { 1068, "Encapsulation: Base operation (and encapsulated PDUs) not executed based on pre-screening analysis" }, + { 1069, "No syntaxes available for this request" }, + { 1070, "user not authorized to receive record(s) in requested syntax" }, + { 1071, "preferredRecordSyntax not supplied" }, + { 1072, "Query term includes characters that do not translate into the target character set" }, + { 1073, "Database records do not contain data associated with access point" }, + { 1074, "Proxy failure" }, + { 0, NULL} +}; + +#include "packet-z3950-hf.c" + +static int hf_z3950_referenceId_printable = -1; +static int hf_z3950_general_printable = -1; + +/* Initialize the subtree pointers */ +static int ett_z3950 = -1; + +#include "packet-z3950-ett.c" + +/* MARC variables and forwards */ + +static int dissect_marc_record(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void * data _U_); + +/* MARC fields */ +static int hf_marc_record = -1; +static int hf_marc_record_terminator = -1; +static int hf_marc_leader = -1; +static int hf_marc_leader_length = -1; +static int hf_marc_leader_status = -1; +static int hf_marc_leader_type = -1; +static int hf_marc_leader_biblevel = -1; +static int hf_marc_leader_control = -1; +static int hf_marc_leader_encoding = -1; +static int hf_marc_leader_indicator_count = -1; +static int hf_marc_leader_subfield_count = -1; +static int hf_marc_leader_data_offset = -1; +static int hf_marc_leader_encoding_level = -1; +static int hf_marc_leader_descriptive_cataloging = -1; +static int hf_marc_leader_multipart_level = -1; +static int hf_marc_leader_length_of_field_length = -1; +static int hf_marc_leader_starting_character_position_length = -1; +static int hf_marc_leader_implementation_defined_length = -1; +static int hf_marc_directory = -1; +static int hf_marc_directory_entry = -1; +static int hf_marc_directory_entry_tag = -1; +static int hf_marc_directory_entry_length = -1; +static int hf_marc_directory_entry_starting_position = -1; +static int hf_marc_directory_terminator = -1; +static int hf_marc_fields = -1; +static int hf_marc_field = -1; +static int hf_marc_field_control = -1; +static int hf_marc_field_terminator = -1; +static int hf_marc_field_indicator1 = -1; +static int hf_marc_field_indicator2 = -1; +static int hf_marc_field_subfield_indicator = -1; +static int hf_marc_field_subfield_tag = -1; +static int hf_marc_field_subfield = -1; + +/* MARC subtree pointers */ +static int ett_marc_record = -1; +static int ett_marc_leader = -1; +static int ett_marc_directory = -1; +static int ett_marc_directory_entry = -1; +static int ett_marc_fields = -1; +static int ett_marc_field = -1; + +/* MARC expert fields */ +static expert_field ei_marc_invalid_length = EI_INIT; +static expert_field ei_marc_invalid_value = EI_INIT; +static expert_field ei_marc_invalid_record_length = EI_INIT; + +/* MARC value strings */ + +static const value_string marc_tag_names[] = { + { 1, "Control Number" }, + { 3, "Control Number Identifier" }, + { 5, "Date and Time of Latest Transaction" }, + { 6, "Fixed-length Data Elements - Addiional Matieral Characteristics" }, + { 8, "Fixed-length Data Elements" }, + { 7, "Physical Description Fixed Field" }, + { 10, "Library of Congress Control Number" }, + { 15, "National Bibliography Number" }, + { 16, "National Bibliographic Agency Control Number" }, + { 17, "Copyright or Legal Deposit Number" }, + { 20, "International Standard Book Number (ISBN)" }, + { 22, "International Standard Serial Number (ISSN)" }, + { 24, "Other Standard Identifier" }, + { 25, "Overseas Acquisition Number" }, + { 26, "Fingerprint Identifier" }, + { 27, "Standard Technical Report Number" }, + { 28, "Publisher or Distributor Number" }, + { 30, "CODEN Designation" }, + { 32, "Postal Registration Number" }, + { 33, "Date/Time and Place of an Event" }, + { 35, "System Control Number" }, + { 37, "Source of Acquisition" }, + { 38, "Record Content Licensor" }, + { 40, "Cataloging Source" }, + { 41, "Language Code" }, + { 42, "Authentication Code" }, + { 43, "Geographic Area Code" }, + { 44, "Country of Publishing/Producing Entity Code" }, + { 45, "Time Period of Content" }, + { 47, "Form of Musical Composition Code" }, + { 50, "Library of Congress Call Number" }, + { 51, "Library of Congress Copy, Issue, Offprint Statement" }, + { 60, "National Library of Medicine Call Number" }, + { 66, "Character Sets Present" }, + { 80, "Universal Decimal Classification Number" }, + { 82, "Dewey Decimal Classification Number" }, + { 83, "Additional Dewey Decimal Classification Number" }, + { 84, "Other Classification Number" }, + { 100, "Main Entry - Personal Name" }, + { 110, "Main Entry - Corporate Name" }, + { 111, "Main Entry - Meeting Name" }, + { 130, "Main Entry - Uniform Title" }, + { 210, "Abbreviated Title" }, + { 222, "Key Title" }, + { 240, "Uniform Title" }, + { 242, "Translation of Title by Cataloging Agency" }, + { 243, "Collective Uniform Title" }, + { 245, "Title Statement" }, + { 246, "Varying Form of Title" }, + { 247, "Former Title" }, + { 249, "Local LoC Varying Form of Title" }, + { 250, "Edition Statement" }, + { 260, "Publication, Distribution, etc. (Imprint)" }, + { 264, "Production, Publication, Distribution, Manufacture, and Copyright Notice" }, + { 300, "Physical Description" }, + { 310, "Current Publication Frequency" }, + { 321, "former Publication Frequency" }, + { 336, "Content Type" }, + { 337, "Media Type" }, + { 338, "Carrier Type" }, + { 340, "Physical Medium" }, + { 362, "Dates of Publication and/or Sequential Designation" }, + { 400, "Series Statement/Added Entry-Personal Name" }, + { 410, "Series Statement/Added Entry-Corporate Name" }, + { 411, "Series Statement/Added Entry-Meeting Name" }, + { 440, "Series Statement/Added Entry-Title" }, + { 490, "Series Statement" }, + { 500, "General Note" }, + { 504, "Bibliography, etc. Note" }, + { 505, "Formatted Contents Note" }, + { 506, "Restrictions on Access Note" }, + { 508, "Creation/Production Credits Note" }, + { 510, "Citation/References Note" }, + { 511, "Participant or Performer Note" }, + { 515, "Numbering Peculiarities Note" }, + { 518, "Date/Time and Place of an Event Note" }, + { 520, "Summary, etc." }, + { 521, "Target Audience Note" }, + { 522, "Geographic Coverage Note" }, + { 524, "Preferred Citation of Described Materials Note" }, + { 525, "Supplement Note" }, + { 530, "Additional Physical Form available Note" }, + { 532, "Accessibility Note" }, + { 533, "Reproduction Note" }, + { 534, "Original Version Note" }, + { 538, "System Details Note" }, + { 540, "Terms Governing Use and Reproduction Note" }, + { 541, "Immediate Source of Acquisition Note" }, + { 542, "Information Relating to Copyright Status" }, + { 546, "Language Note" }, + { 550, "Issuing Body Note" }, + { 555, "Cumulative Index/Finding Aids Note" }, + { 583, "Action Note" }, + { 588, "Source of Description, Etc. Note" }, + { 590, "Local LoC Note" }, + { 591, "Local LoC \"With\" Note" }, + { 592, "Local LoC Acquisition Note" }, + { 600, "Subject Added Entry - Personal Name" }, + { 610, "Subject Added Entry - Corporate Name" }, + { 611, "Subject Added Entry - Meeting Name" }, + { 630, "Subject Added Entry - Uniform Title" }, + { 647, "Subject Added Entry - Named Event" }, + { 648, "Subject Added Entry - Chronological Term" }, + { 650, "Subject Added Entry - Topical Term" }, + { 651, "Subject Added Entry - Geographic Name" }, + { 653, "Index Term - Uncontrolled" }, + { 654, "Subject Added Entry - Faceted Topical Terms" }, + { 655, "Index Term - Genre/Form" }, + { 656, "Index Term - Occupation" }, + { 657, "Index Term - Function" }, + { 658, "Index Term - Curriculum Objective" }, + { 662, "Subject Added Entry - Hierarchical Place Name" }, + { 700, "Added Entry - Personal Name" }, + { 710, "Added Entry - Corporate Name" }, + { 711, "Added Entry - Meeting Name" }, + { 720, "Added Entry - Uncontrolled Name" }, + { 730, "Added Entry - Uniform Title" }, + { 740, "Added Entry - Uncontrolled Related/Analytical Title" }, + { 751, "Added Entry - Geographic Name" }, + { 752, "Added Entry - Hierarchical Place Name" }, + { 753, "System Details Access to Computer Files" }, + { 754, "Added Entry - Taxonomic Identification" }, + { 758, "Resource Identifier" }, + { 760, "Main Series Entry" }, + { 762, "Subseries Entry" }, + { 765, "Original Language Entry" }, + { 767, "Translation Entry" }, + { 770, "Supplement/Special Issue Entry" }, + { 772, "Supplement Parent Entry" }, + { 773, "Host Item Entry" }, + { 774, "Constituent Unit Entry" }, + { 775, "Other Edition Entry" }, + { 776, "Additional Physical Form Entry" }, + { 777, "Issued With Entry" }, + { 780, "Preceding Entry" }, + { 785, "Succeeding Entry" }, + { 786, "Data Source Entry" }, + { 787, "Other Relationship Entry" }, + { 800, "Series Added Entry - Personal Name" }, + { 810, "Series Added Entry - Corporate Name" }, + { 811, "Series Added Entry - Meeting Name" }, + { 830, "Series Added Entry - Uniform Title" }, + { 850, "Holding Institution" }, + { 852, "Location" }, + { 853, "Captions and Pattern - Basic Bibliographic Unit" }, + { 856, "Electronic Location and Access" }, + { 859, "Local LoC Electronic Location and Access" }, + { 863, "Enumeration and Chronology - Basic Bibliographic Unit" }, + { 880, "Alternate Graphic Representation" }, + { 890, "Local LoC Visible File Entry" }, + { 906, "Local LoC Processing Data" }, + { 920, "Local LoC Selection Decision" }, + { 922, "Local LoC Book Source" }, + { 923, "Local LoC Supplier Invoice or Shipment Id" }, + { 925, "Local LoC Selection Decision" }, + { 952, "Local LoC Cataloger's Permanent Note" }, + { 955, "Local LoC Functional Identifying Information" }, + { 984, "Local LoC Shelflist Compare Status" }, + { 985, "Local LoC Record History" }, + { 987, "Local LoC Converstion History" }, + { 991, "Local LoC Location Information" }, + { 992, "Local LoC Location Information" }, + { 0, NULL} +}; + +static int +dissect_z3950_printable_OCTET_STRING(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + tvbuff_t *next_tvb = NULL; + int hf_alternate = -1; + guint old_offset = offset; + + if (hf_index == hf_z3950_referenceId) { + hf_alternate = hf_z3950_referenceId_printable; + } + else if ( hf_index == hf_z3950_general) { + hf_alternate = hf_z3950_general_printable; + } + + if (hf_alternate > 0) { + /* extract the value of the octet string so we can look at it. */ + /* This does not display anything because tree is NULL. */ + offset = dissect_ber_octet_string(implicit_tag, actx, NULL, tvb, offset, hf_index, &next_tvb); + + if (next_tvb && + tvb_ascii_isprint(next_tvb, 0, tvb_reported_length(next_tvb))) { + proto_tree_add_item(tree, hf_alternate, next_tvb, + 0, tvb_reported_length(next_tvb), ENC_ASCII|ENC_NA); + } + else { + offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, + old_offset, hf_index, NULL); + } + } + else { + offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, + old_offset, hf_index, NULL); + } + + return offset; +} + +#include "packet-z3950-fn.c" + +static int +dissect_z3950(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_) +{ + proto_item *z3950_item = NULL; + proto_tree *z3950_tree = NULL; + int offset = 0; + asn1_ctx_t asn1_ctx; + asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo); + + + /* make entry in the Protocol column on summary display */ + col_set_str(pinfo->cinfo, COL_PROTOCOL, PSNAME); + + /* create the z3950 protocol tree */ + z3950_item = proto_tree_add_item(tree, proto_z3950, tvb, 0, -1, FALSE); + z3950_tree = proto_item_add_subtree(z3950_item, ett_z3950); + + return dissect_z3950_PDU(FALSE, tvb, offset, &asn1_ctx, z3950_tree, -1); +} + +static guint +get_z3950_pdu_len(packet_info *pinfo _U_, tvbuff_t *tvb, int offset, void *data _U_) +{ + guint plen; + guint ber_offset; + TRY { + /* Skip past identifier */ + ber_offset = get_ber_identifier(tvb, offset, NULL, NULL, NULL); + ber_offset = get_ber_length(tvb, ber_offset, &plen, NULL); + plen += (ber_offset - offset); + } + CATCH(ReportedBoundsError) { + plen = 0; + } + ENDTRY; + + return plen; +} + +static int +dissect_z3950_segment(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void * data _U_) +{ + + /* Min length of 8 assumes 3 for identifer and 5 for length. */ + tcp_dissect_pdus(tvb, pinfo, tree, z3950_desegment, 8, get_z3950_pdu_len, dissect_z3950, data); + return tvb_captured_length(tvb); +} + +/*--- proto_register_z3950 -------------------------------------------*/ +void proto_register_z3950(void) { + + /* List of fields */ + static hf_register_info hf[] = { + +#include "packet-z3950-hfarr.c" + + { &hf_z3950_referenceId_printable, + { "referenceId", "z3950.referenceId.printable", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_general_printable, + { "general", "z3950.general.printable", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + +/* MARC hf definitions */ + { &hf_marc_record, + { "MARC record", "marc", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_record_terminator, + { "MARC record terminator", "marc.terminator", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader, + { "MARC leader", "marc.leader", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_length, + { "MARC leader length", "marc.leader.length", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_status, + { "MARC leader status", "marc.leader.status", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_type, + { "MARC leader type", "marc.leader.type", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_biblevel, + { "MARC leader biblevel", "marc.leader.biblevel", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_control, + { "MARC leader control", "marc.leader.control", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_encoding, + { "MARC leader encoding", "marc.leader.encoding", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_indicator_count, + { "MARC leader indicator count", "marc.leader.indicator_count", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_subfield_count, + { "MARC leader subfield count", "marc.leader.subfield_count", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_data_offset, + { "MARC leader data offset", "marc.leader.data_offset", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_encoding_level, + { "MARC leader encoding level", "marc.leader.encoding_level", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_descriptive_cataloging, + { "MARC leader descriptive cataloging", "marc.leader.descriptive_cataloging", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_multipart_level, + { "MARC leader multipart level", "marc.leader.multipart_level", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_length_of_field_length, + { "MARC leader length-of-field length", "marc.leader.length_of_field_length", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_starting_character_position_length, + { "MARC leader starting-character-position length", "marc.leader.starting_character_position_length", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_implementation_defined_length, + { "MARC leader implementation-defined length", "marc.leader.implementation_defined_length", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_directory, + { "MARC directory", "marc.directory", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_directory_entry, + { "MARC directory entry", "marc.directory.entry", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_directory_entry_tag, + { "tag", "marc.directory.entry.tag", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_directory_entry_length, + { "length", "marc.directory.entry.length", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_directory_entry_starting_position, + { "starting position", "marc.directory.entry.starting_position", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_directory_terminator, + { "MARC directory terminator", "marc.directory.terminator", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_fields, + { "MARC data fields", "marc.fields", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_field, + { "MARC field", "marc.field", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_field_control, + { "Control field", "marc.field.control", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_field_terminator, + { "MARC field terminator", "marc.field.terminator", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_field_indicator1, + { "MARC field indicator1", "marc.field.indicator1", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_field_indicator2, + { "MARC field indicator2", "marc.field.indicator2", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_field_subfield_indicator, + { "MARC field subfield indicator", "marc.field.subfield.indicator", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_field_subfield_tag, + { "MARC field subfield tag", "marc.field.subfield.tag", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_field_subfield, + { "MARC Subfield", "marc.field.subfield", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + + }; + + /* List of subtrees */ + static gint *ett[] = { + &ett_z3950, +/* MARC etts */ + &ett_marc_record, + &ett_marc_leader, + &ett_marc_directory, + &ett_marc_directory_entry, + &ett_marc_fields, + &ett_marc_field, +#include "packet-z3950-ettarr.c" + }; + + module_t *z3950_module; + +/* Expert info */ + static ei_register_info ei[] = { +/* Z39.50 expert info */ + +/* MARC expert info */ + { &ei_marc_invalid_length, { "marc.invalid_length", PI_MALFORMED, PI_ERROR, + "MARC record too short", EXPFILL }}, + { &ei_marc_invalid_value, { "marc.invalid_value", PI_MALFORMED, PI_ERROR, + "MARC field has invalid value", EXPFILL }}, + { &ei_marc_invalid_record_length, { "marc.invalid_record_length", PI_MALFORMED, PI_ERROR, + "MARC length field has invalid value", EXPFILL }}, + }; + + expert_module_t* expert_z3950; + + + /* Register protocol */ + proto_z3950 = proto_register_protocol(PNAME, PSNAME, PFNAME); + /* Register fields and subtrees */ + proto_register_field_array(proto_z3950, hf, array_length(hf)); + proto_register_subtree_array(ett, array_length(ett)); + expert_z3950 = expert_register_protocol(proto_z3950); + expert_register_field_array(expert_z3950, ei, array_length(ei)); + + /* Register preferences */ + z3950_module = prefs_register_protocol(proto_z3950, NULL); + prefs_register_bool_preference(z3950_module, "desegment_buffers", + "Reassemble Z39.50 buffers spanning multiple TCP segments", + "Whether the Z39.50 dissector should reassemble TDS buffers spanning multiple TCP segments. " + "To use this option, you must also enable \"Allow subdissectors to reassemble TCP streams\" in the TCP protocol settings.", + &z3950_desegment); + + /* Allow dissector to be found by name. */ + z3950_handle = register_dissector(PSNAME, dissect_z3950_segment, + proto_z3950); + +} + +/*--- proto_reg_handoff_z3950 ---------------------------------------*/ +void +proto_reg_handoff_z3950(void) +{ + + dissector_add_uint_with_preference("tcp.port", + global_z3950_port, z3950_handle); + +#include "packet-z3950-dis-tab.c" + + register_ber_oid_dissector(Z3950_RECORDSYNTAX_MARC21_OID, dissect_marc_record, proto_z3950, "MARC21"); + + oid_add_from_string("Z39.50", "1.2.840.10003"); + oid_add_from_string("Z39.50-APDU", "1.2.840.10003.2"); + oid_add_from_string("Z39.50-attributeSet", "1.2.840.10003.3"); + oid_add_from_string("Z39.50-diagnostic", "1.2.840.10003.4"); + oid_add_from_string("Z39.50-recordSyntax", "1.2.840.10003.5"); + oid_add_from_string("Z39.50-resourceReport", "1.2.840.10003.7"); + oid_add_from_string("Z39.50-accessControl", "1.2.840.10003.8"); + oid_add_from_string("Z39.50-extendedService", "1.2.840.10003.9"); + oid_add_from_string("Z39.50-userinfoFormat", "1.2.840.10003.10"); + oid_add_from_string("Z39.50-elementSpec", "1.2.840.10003.11"); + oid_add_from_string("Z39.50-variantSet", "1.2.840.10003.12"); + oid_add_from_string("Z39.50-schema", "1.2.840.10003.13"); + oid_add_from_string("Z39.50-tagSet", "1.2.840.10003.14"); + oid_add_from_string("Z39.50-negotiation", "1.2.840.10003.15"); + oid_add_from_string("Z39.50-query", "1.2.840.10003.16"); + /* MARC Record Syntaxes */ + oid_add_from_string("UNIMARC","1.2.840.10003.5.1"); + oid_add_from_string("INTERMARC","1.2.840.10003.5.2"); + oid_add_from_string("CCF","1.2.840.10003.5.3"); + oid_add_from_string("MARC21 (formerly USMARC)",Z3950_RECORDSYNTAX_MARC21_OID); + oid_add_from_string("UKMARC","1.2.840.10003.5.11"); + oid_add_from_string("NORMARC","1.2.840.10003.5.12"); + oid_add_from_string("Librismarc","1.2.840.10003.5.13"); + oid_add_from_string("danMARC2","1.2.840.10003.5.14"); + oid_add_from_string("Finmarc","1.2.840.10003.5.15"); + oid_add_from_string("MAB","1.2.840.10003.5.16"); + oid_add_from_string("Canmarc","1.2.840.10003.5.17"); + oid_add_from_string("SBN","1.2.840.10003.5.18"); + oid_add_from_string("Picamarc","1.2.840.10003.5.19"); + oid_add_from_string("Ausmarc","1.2.840.10003.5.20"); + oid_add_from_string("Ibermarc","1.2.840.10003.5.21"); + oid_add_from_string("Catmarc","1.2.840.10003.5.22"); + oid_add_from_string("Malmarc","1.2.840.10003.5.23"); + oid_add_from_string("JPmarc","1.2.840.10003.5.24"); + oid_add_from_string("SWEMarc","1.2.840.10003.5.25"); + oid_add_from_string("SIGLEmarc","1.2.840.10003.5.26"); + oid_add_from_string("ISDS/ISSNmarc","1.2.840.10003.5.27"); + oid_add_from_string("RUSMarc","1.2.840.10003.5.28"); + oid_add_from_string("Hunmarc","1.2.840.10003.5.29"); + oid_add_from_string("NACSIS-CATP","1.2.840.10003.5.30"); + oid_add_from_string("FINMARC2000","1.2.840.10003.5.31"); + oid_add_from_string("MARC21-fin","1.2.840.10003.5.32"); + oid_add_from_string("COMARC","1.2.840.10003.5.33"); + /* Non-MARC record syntaxes */ + oid_add_from_string("Explain","1.2.840.10003.5.100"); + oid_add_from_string("Explain with ZSQL","1.2.840.10003.5.100.1"); + oid_add_from_string("SUTRS","1.2.840.10003.5.101"); + oid_add_from_string("OPAC","1.2.840.10003.5.102"); + oid_add_from_string("Summary","1.2.840.10003.5.103"); + oid_add_from_string("GRS-0","1.2.840.10003.5.104"); + oid_add_from_string("GRS-1","1.2.840.10003.5.105"); + oid_add_from_string("ESTaskPackage","1.2.840.10003.5.106"); + oid_add_from_string("fragment","1.2.840.10003.5.108"); + /* Attribute sets */ + oid_add_from_string("bib-1",Z3950_ATSET_BIB1_OID); + oid_add_from_string("exp-1","1.2.840.10003.3.2"); + oid_add_from_string("ext-1","1.2.840.10003.3.3"); + oid_add_from_string("ccl-1","1.2.840.10003.3.4"); + oid_add_from_string("gils","1.2.840.10003.3.5"); + oid_add_from_string("stas","1.2.840.10003.3.6"); + oid_add_from_string("collections-1","1.2.840.10003.3.7"); + oid_add_from_string("cimi-1","1.2.840.10003.3.8"); + oid_add_from_string("geo-1","1.2.840.10003.3.9"); + oid_add_from_string("ZBIG","1.2.840.10003.3.10"); + oid_add_from_string("util","1.2.840.10003.3.11"); + oid_add_from_string("xd-1","1.2.840.10003.3.12"); + oid_add_from_string("Zthes","1.2.840.10003.3.13"); + oid_add_from_string("Fin-1","1.2.840.10003.3.14"); + oid_add_from_string("Dan-1","1.2.840.10003.3.15"); + oid_add_from_string("Holdings","1.2.840.10003.3.16"); + oid_add_from_string("MARC","1.2.840.10003.3.17"); + oid_add_from_string("bib-2","1.2.840.10003.3.18"); + oid_add_from_string("ZeeRex","1.2.840.10003.3.19"); + /* Diagnostic sets */ + oid_add_from_string("bib-1-diagnostics",Z3950_DIAGSET_BIB1_OID); + +} + +/* MARC routines */ + +static int +dissect_marc_record(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void * data _U_) +{ + proto_item *record_item, *leader_item, + *directory_item, + *fields_item, + *item; + proto_tree *marc_tree, *leader_tree, + *directory_tree, + *fields_tree; + marc_directory_entry *marc_directory; + guint len = tvb_reported_length(tvb); + const guint8 *marc_value_str; + guint record_length = 0, + data_offset = 0, + length_of_field_size, + starting_character_position_size, + directory_entry_len, + directory_entry_count, + dir_index, + offset = 0; + guint32 marc_value_char; + + record_item = proto_tree_add_item(tree, hf_marc_record, + tvb, 0, len, ENC_NA); + marc_tree = proto_item_add_subtree(record_item, ett_marc_record); + if (len < MARC_LEADER_LENGTH) { + expert_add_info_format(pinfo, record_item, + &ei_marc_invalid_record_length, + "MARC record length %d is shorter than leader", len); + } + leader_item = proto_tree_add_item(marc_tree, hf_marc_leader, tvb, 0, + MARC_LEADER_LENGTH, ENC_NA); + leader_tree = proto_item_add_subtree(leader_item, ett_marc_leader); + + marc_value_str = NULL; + item = proto_tree_add_item_ret_string(leader_tree, + hf_marc_leader_length, tvb, offset, 5, ENC_ASCII|ENC_NA, + wmem_packet_scope(),&marc_value_str); + offset += 5; + + if (marc_value_str) { + if (isdigit_string(marc_value_str)) { + record_length = (guint)strtoul(marc_value_str, NULL, 10); + } + else { + expert_add_info_format(pinfo, item, + &ei_marc_invalid_value, + "MARC length field '%s' contains invalid characters", + marc_value_str ); + } + if (record_length != len) { + expert_add_info_format(pinfo, item, + &ei_marc_invalid_length, + "MARC length field value %d does not match reported length %d", + record_length, len); + } + } + + proto_tree_add_item(leader_tree, hf_marc_leader_status, tvb, offset, 1, ENC_ASCII); + offset += 1; + proto_tree_add_item(leader_tree, hf_marc_leader_type, tvb, offset, 1, ENC_ASCII); + offset += 1; + proto_tree_add_item(leader_tree, hf_marc_leader_biblevel, tvb, offset, 1, ENC_ASCII); + offset += 1; + proto_tree_add_item(leader_tree, hf_marc_leader_control, tvb, offset, 1, ENC_ASCII); + offset += 1; + proto_tree_add_item(leader_tree, hf_marc_leader_encoding, tvb, offset, 1, ENC_ASCII); + offset += 1; + marc_value_char = MARC_CHAR_UNINITIALIZED; + item = proto_tree_add_item_ret_uint(leader_tree, hf_marc_leader_indicator_count, + tvb, offset, 1, ENC_ASCII, &marc_value_char); + offset += 1; + if (marc_value_char != MARC_CHAR_UNINITIALIZED) { + if (!marc_isdigit(marc_value_char)) { + expert_add_info_format(pinfo, item, &ei_marc_invalid_value, + "Indicator count '%c' is invalid", marc_value_char); + } + else { + if (marc_char_to_int(marc_value_char) != 2) { + expert_add_info_format(pinfo, item, &ei_marc_invalid_length, + "MARC21 requires indicator count equal 2, not %d", + marc_char_to_int(marc_value_char)); + } + } + } + + marc_value_char = MARC_CHAR_UNINITIALIZED; + item = proto_tree_add_item_ret_uint(leader_tree, hf_marc_leader_subfield_count, + tvb, offset, 1, ENC_ASCII, &marc_value_char); + offset += 1; + if (marc_value_char != MARC_CHAR_UNINITIALIZED) { + if (!marc_isdigit(marc_value_char)) { + expert_add_info_format(pinfo, item, &ei_marc_invalid_value, + "Subfield count '%c' is invalid", marc_value_char); + } + else { + if (marc_char_to_int(marc_value_char) != 2) { + expert_add_info_format(pinfo, item, &ei_marc_invalid_length, + "MARC21 requires subfield count equal 2, not %d", + marc_char_to_int(marc_value_char)); + } + } + } + + item = proto_tree_add_item_ret_string(leader_tree, hf_marc_leader_data_offset, + tvb, offset, 5, ENC_ASCII|ENC_NA, + wmem_packet_scope(),&marc_value_str); + offset += 5; + if (marc_value_str) { + if (isdigit_string(marc_value_str)) { + data_offset = (guint)strtoul(marc_value_str, NULL, 10); + } + else { + expert_add_info_format(pinfo, item, + &ei_marc_invalid_value, + "MARC data offset field '%s' contains invalid characters", + marc_value_str ); + } + if (data_offset < MARC_LEADER_LENGTH || + data_offset > record_length) { + expert_add_info_format(pinfo, item, + &ei_marc_invalid_length, + "MARC data offset %d does not lie within record (length %d)", + data_offset, len); + } + } + proto_tree_add_item(leader_tree, hf_marc_leader_encoding_level, tvb, offset, 1, ENC_ASCII); + offset += 1; + proto_tree_add_item(leader_tree, hf_marc_leader_descriptive_cataloging, tvb, offset, 1, ENC_ASCII); + offset += 1; + proto_tree_add_item(leader_tree, hf_marc_leader_multipart_level, tvb, offset, 1, ENC_ASCII); + offset += 1; + marc_value_char = MARC_CHAR_UNINITIALIZED; + item = proto_tree_add_item_ret_uint(leader_tree, hf_marc_leader_length_of_field_length, + tvb, offset, 1, ENC_ASCII, &marc_value_char); + offset += 1; + length_of_field_size = 4; + if (marc_value_char != MARC_CHAR_UNINITIALIZED) { + if (!marc_isdigit(marc_value_char)) { + expert_add_info_format(pinfo, item, &ei_marc_invalid_value, + "Length-of field-length '%c' is invalid", marc_value_char); + } + else { + if (marc_char_to_int(marc_value_char) != 4) { + expert_add_info_format(pinfo, item, &ei_marc_invalid_length, + "MARC21 requires length-of-field equal 4, not %d", + marc_char_to_int(marc_value_char)); + } + } + } + + marc_value_char = MARC_CHAR_UNINITIALIZED; + item = proto_tree_add_item_ret_uint(leader_tree, hf_marc_leader_starting_character_position_length, + tvb, offset, 1, ENC_ASCII, &marc_value_char); + offset += 1; + starting_character_position_size = 5; + if (marc_value_char != MARC_CHAR_UNINITIALIZED) { + if (!marc_isdigit(marc_value_char)) { + expert_add_info_format(pinfo, item, &ei_marc_invalid_value, + "Starting-character-position length '%c' is invalid", marc_value_char); + } + else { + if (marc_char_to_int(marc_value_char) != 5) { + expert_add_info_format(pinfo, item, &ei_marc_invalid_length, + "MARC21 requires starting-character-position equal 5, not %d", + marc_char_to_int(marc_value_char)); + } + } + } + + proto_tree_add_item(leader_tree, hf_marc_leader_implementation_defined_length, tvb, offset, 1, ENC_ASCII); + offset += 1; + + /* One position is defined as unused-must-be-zero. + * Don't bother displaying or checking it. */ + offset += 1; + + /* Process the directory */ + + directory_entry_len = 3 + length_of_field_size + + starting_character_position_size; + directory_entry_count = ((data_offset - 1) - MARC_LEADER_LENGTH) / directory_entry_len; + + marc_directory = (marc_directory_entry *)wmem_alloc0(wmem_packet_scope(), + directory_entry_count * sizeof(marc_directory_entry)); + + directory_item = proto_tree_add_item(marc_tree, hf_marc_directory, + tvb, offset, data_offset - offset, ENC_NA); + directory_tree = proto_item_add_subtree(directory_item, ett_marc_directory); + + dir_index = 0; + /* Minus one for the terminator character */ + while (offset < (data_offset - 1)) { + guint32 tag_value = 0, + length_value = 0, + starting_char_value = 0; + proto_item *length_item; + proto_item *directory_entry_item; + proto_tree *directory_entry_tree; + + directory_entry_item = proto_tree_add_item(directory_tree, hf_marc_directory_entry, + tvb, offset, directory_entry_len, ENC_NA); + directory_entry_tree = proto_item_add_subtree(directory_entry_item, ett_marc_directory_entry); + + marc_value_str = NULL; + item = proto_tree_add_item_ret_string(directory_entry_tree, hf_marc_directory_entry_tag, + tvb, offset, 3, ENC_ASCII, + wmem_packet_scope(), &marc_value_str); + offset += 3; + if (marc_value_str) { + if (isdigit_string(marc_value_str)) { + tag_value = (guint)strtoul(marc_value_str, NULL, 10); + } + else { + expert_add_info_format(pinfo, item, + &ei_marc_invalid_value, + "MARC directory tag value %d ('%s') contains invalid characters", + dir_index, marc_value_str ); + } + } + marc_value_str = NULL; + length_item = proto_tree_add_item_ret_string(directory_entry_tree, + hf_marc_directory_entry_length, + tvb, offset, length_of_field_size, ENC_ASCII, + wmem_packet_scope(), &marc_value_str); + offset += length_of_field_size; + if (marc_value_str) { + if (isdigit_string(marc_value_str)) { + length_value = (guint)strtoul(marc_value_str, NULL, 10); + } + else { + expert_add_info_format(pinfo, length_item, + &ei_marc_invalid_value, + "MARC directory length value %d ('%s') contains invalid characters", + dir_index, marc_value_str ); + } + } + marc_value_str = NULL; + item = proto_tree_add_item_ret_string(directory_entry_tree, hf_marc_directory_entry_starting_position, + tvb, offset, starting_character_position_size, ENC_ASCII, + wmem_packet_scope(), &marc_value_str); + offset += starting_character_position_size; + if (marc_value_str) { + if (isdigit_string(marc_value_str)) { + starting_char_value = (guint)strtoul(marc_value_str, NULL, 10); + } + else { + expert_add_info_format(pinfo, item, + &ei_marc_invalid_value, + "MARC directory entry %d starting char value '%s' contains invalid characters", + dir_index, marc_value_str ); + } + } + + if (starting_char_value >= (record_length - data_offset)) { + expert_add_info_format(pinfo, item, + &ei_marc_invalid_value, + "MARC directory entry %d starting char value %d is outside record size %d", + dir_index, starting_char_value, (record_length - data_offset)); + } + if ((starting_char_value + length_value) >= (record_length - data_offset)) { + expert_add_info_format(pinfo, length_item, + &ei_marc_invalid_value, + "MARC directory entry %d length value %d goes outside record size %d", + dir_index, length_value, (record_length - data_offset)); + } + marc_directory[dir_index].tag = tag_value; + marc_directory[dir_index].length = length_value; + marc_directory[dir_index].starting_character = starting_char_value; + dir_index++; + } + proto_tree_add_item(directory_tree, hf_marc_directory_terminator, + tvb, offset, 1, ENC_ASCII); + offset += 1; + + fields_item = proto_tree_add_item(marc_tree, hf_marc_fields, + tvb, offset, record_length - offset, ENC_NA); + fields_tree = proto_item_add_subtree(fields_item, ett_marc_fields); + + for (dir_index = 0; dir_index < directory_entry_count; dir_index++) { + const gchar *tag_str; + proto_item *field_item; + proto_tree *field_tree; + + field_item = proto_tree_add_item(fields_tree, hf_marc_field, + tvb, offset, marc_directory[dir_index].length, ENC_NA); + field_tree = proto_item_add_subtree(field_item, ett_marc_field); + + tag_str = try_val_to_str(marc_directory[dir_index].tag, marc_tag_names); + if (tag_str) { + proto_item_append_text(field_item," Tag %03d (%s)", + marc_directory[dir_index].tag, tag_str); + } + else { + proto_item_append_text(field_item," Tag %03d", + marc_directory[dir_index].tag); + } + + if (marc_directory[dir_index].tag < 10) { + proto_tree_add_item(field_tree, hf_marc_field_control, + tvb, offset, marc_directory[dir_index].length - 1, ENC_ASCII|ENC_NA); + offset += marc_directory[dir_index].length - 1; + proto_tree_add_item(field_tree, hf_marc_field_terminator, + tvb, offset, 1, ENC_ASCII); + offset += 1; + } + else { + guint next_offset = offset + marc_directory[dir_index].length - 1; + proto_tree_add_item(field_tree, hf_marc_field_indicator1, + tvb, offset, 1, ENC_ASCII); + offset += 1; + proto_tree_add_item(field_tree, hf_marc_field_indicator2, + tvb, offset, 1, ENC_ASCII); + offset += 1; + do { + gint next_subfield; + proto_tree_add_item(field_tree, hf_marc_field_subfield_indicator, + tvb, offset, 1, ENC_ASCII); + offset += 1; + proto_tree_add_item(field_tree, hf_marc_field_subfield_tag, + tvb, offset, 1, ENC_ASCII); + offset += 1; + next_subfield = tvb_find_guint8(tvb, offset, next_offset - offset, + MARC_SUBFIELD_INDICATOR); + if (next_subfield >= 0) { + proto_tree_add_item(field_tree, hf_marc_field_subfield, + tvb, offset, next_subfield - offset, ENC_ASCII|ENC_NA); + offset += (next_subfield - offset); + } + else { + proto_tree_add_item(field_tree, hf_marc_field_subfield, + tvb, offset, next_offset - offset, ENC_ASCII|ENC_NA); + offset = next_offset; + } + } while (offset < next_offset); + proto_tree_add_item(field_tree, hf_marc_field_terminator, + tvb, offset, 1, ENC_ASCII); + offset += 1; + } + + } + proto_tree_add_item(marc_tree, hf_marc_record_terminator, + tvb, offset, 1, ENC_ASCII); + offset += 1; + + if (offset != len) { + expert_add_info_format(pinfo, record_item, + &ei_marc_invalid_record_length, + "MARC record component length %d does not match record length %d", + offset, len); + } + + return len; +} + +/* + * Editor modelines + * + * Local Variables: + * c-basic-offset: 4 + * tab-width: 8 + * indent-tabs-mode: nil + * End: + * + * ex: set shiftwidth=4 tabstop=8 expandtab: + * :indentSize=4:tabSize=8:noTabs=true: + */ diff --git a/epan/dissectors/asn1/z3950/z3950-externals.asn b/epan/dissectors/asn1/z3950/z3950-externals.asn new file mode 100644 index 0000000000..4ce9683617 --- /dev/null +++ b/epan/dissectors/asn1/z3950/z3950-externals.asn @@ -0,0 +1,1679 @@ +RecordSyntax-SUTRS +{z39-50-recordSyntax sutrs (101)} DEFINITIONS ::= +BEGIN +IMPORTS InternationalString FROM Z39-50-APDU-1995; + SutrsRecord ::= InternationalString +-- Line terminator is ASCII LF (X'0A'). +-- Recommended maximum line length is 72 characters. +END + +RecordSyntax-opac +{z39-50-recordSyntax opac (102)} DEFINITIONS ::= +BEGIN +IMPORTS InternationalString FROM Z39-50-APDU-1995; + +OPACRecord ::= SEQUENCE { + bibliographicRecord [1] IMPLICIT EXTERNAL OPTIONAL, + holdingsData [2] IMPLICIT SEQUENCE OF HoldingsRecord OPTIONAL} + +HoldingsRecord ::= CHOICE { + marcHoldingsRecord [1] IMPLICIT EXTERNAL, + holdingsAndCirc [2] IMPLICIT HoldingsAndCircData} + +HoldingsAndCircData ::= SEQUENCE { + -- the following elements are required to display + -- holdings in conformance with NISO standards. + typeOfRecord [1] IMPLICIT InternationalString OPTIONAL,-- LDR 06 + encodingLevel [2] IMPLICIT InternationalString OPTIONAL, -- LDR 017 + format [3] IMPLICIT InternationalString OPTIONAL, -- 007 + -- 00-01 + receiptAcqStatus [4] IMPLICIT InternationalString OPTIONAL, -- 008 06 + generalRetention [5] IMPLICIT InternationalString OPTIONAL, -- 008 12 + completeness [6] IMPLICIT InternationalString OPTIONAL, -- 008 16 + dateOfReport [7] IMPLICIT InternationalString OPTIONAL, -- 008 + -- 26-31 + nucCode [8] IMPLICIT InternationalString OPTIONAL, -- 852 $a + localLocation [9] IMPLICIT InternationalString OPTIONAL, -- 852 $b + shelvingLocation [10] IMPLICIT InternationalString OPTIONAL, -- 852 $c + callNumber [11] IMPLICIT InternationalString OPTIONAL, -- 852 $h + -- and $i + shelvingData [12] IMPLICIT InternationalString OPTIONAL, -- 852 $j + -- thru $m + copyNumber [13] IMPLICIT InternationalString OPTIONAL, -- 852 $t + publicNote [14] IMPLICIT InternationalString OPTIONAL, -- 852 $z + reproductionNote [15] IMPLICIT InternationalString OPTIONAL, -- 843 + termsUseRepro [16] IMPLICIT InternationalString OPTIONAL, -- 845 + enumAndChron [17] IMPLICIT InternationalString OPTIONAL, -- all 85x, + -- 86x + volumes [18] IMPLICIT SEQUENCE OF Volume OPTIONAL, + -- repeats for each volume held + circulationData [19] IMPLICIT SEQUENCE OF CircRecord OPTIONAL + -- repeats for each circulating item. + } + +Volume ::= SEQUENCE { + enumeration [1] IMPLICIT InternationalString OPTIONAL, + chronology [2] IMPLICIT InternationalString OPTIONAL, + enumAndChron [3] IMPLICIT InternationalString OPTIONAL } + +CircRecord ::= SEQUENCE { + availableNow [1] IMPLICIT BOOLEAN, + availablityDate [2] IMPLICIT InternationalString OPTIONAL, + availableThru [3] IMPLICIT InternationalString OPTIONAL, + restrictions [4] IMPLICIT InternationalString OPTIONAL, + itemId [5] IMPLICIT InternationalString OPTIONAL, + renewable [6] IMPLICIT BOOLEAN, + onHold [7] IMPLICIT BOOLEAN, + enumAndChron [8] IMPLICIT InternationalString OPTIONAL, + midspine [9] IMPLICIT InternationalString OPTIONAL, + temporaryLocation [10] IMPLICIT InternationalString OPTIONAL} +END + +DiagnosticFormatDiag1 +{z39-50-diagnostic diag-1 (2)} DEFINITIONS ::= +BEGIN +IMPORTS Term, Specification, AttributeList, SortElement, +DatabaseName, +DefaultDiagFormat, InternationalString FROM Z39-50-APDU-1995; + + +DiagnosticFormat ::= SEQUENCE OF SEQUENCE{ + diagnostic [1] CHOICE{ + defaultDiagRec [1] IMPLICIT DefaultDiagFormat, + explicitDiagnostic [2] DiagFormat} OPTIONAL, + message [2] IMPLICIT InternationalString OPTIONAL} + + +DiagFormat ::= CHOICE{ + +tooMany [1000] IMPLICIT SEQUENCE{ + tooManyWhat [1] IMPLICIT INTEGER{ + argumentWords (1), + truncatedWords (2), + booleanOperators (3), + incompleteSubfields (4), + characters (5), + recordsRetrieved (6), + dataBasesSpecified (7), + resultSetsCreated (8), + indexTermsProcessed (9)}, + max [2] IMPLICIT INTEGER OPTIONAL}, + + +badSpec [1001] IMPLICIT SEQUENCE{ + -- element set name or specification + spec [1] IMPLICIT Specification, + -- esn or element spec not supported + db [2] IMPLICIT DatabaseName OPTIONAL, + -- if db specified, above spec not + -- supported for db; otherwise, + -- spec not supported period. + goodOnes [3] IMPLICIT SEQUENCE OF Specification + OPTIONAL + -- target supplies ones that are + -- supported + }, + + +dbUnavail [1002] IMPLICIT SEQUENCE{ -- database unavailable + db [1] IMPLICIT DatabaseName, + why [2] IMPLICIT SEQUENCE{ + reasonCode [1] IMPLICIT INTEGER{ + doesNotExist (0), + existsButUnavail (1), + locked (2), + accessDenied (3)} + OPTIONAL, + message [2] IMPLICIT + InternationalString OPTIONAL}}, + + +unSupOp [1003] IMPLICIT INTEGER{ -- unsupported operator + and (0), + or (1), + and-not (2), + prox (3)}, + + +attribute [1004] IMPLICIT SEQUENCE{ + -- Applies for unsupported attribute set, + -- attribute type, attribute value, or term (for + -- a given attribute type or value). + id [1] IMPLICIT OBJECT IDENTIFIER, + -- if only "id" occurs, then + -- attribute set is not supported + type [2] IMPLICIT INTEGER OPTIONAL, + -- must occur if value occurs. + value [3] IMPLICIT INTEGER OPTIONAL, + -- if omitted, and Type occurs, + -- then Type is what is unsupported + term [4] Term OPTIONAL + -- If occurs, term is illegal or + -- not supported, for attribute + -- value, if value occurs; + -- otherwise, for type. + }, + + +attCombo [1005] IMPLICIT SEQUENCE{ + -- attribute combination not supported + unsupportedCombination [1] IMPLICIT AttributeList, + recommendedAlternatives [2] IMPLICIT SEQUENCE OF + AttributeList OPTIONAL}, + + +term [1006] IMPLICIT SEQUENCE{ + problem [1] IMPLICIT INTEGER{ + codedValue (1), + unparsable (2), + tooShort (3), + type (4)} OPTIONAL, + term [2] Term}, + + +proximity [1007] CHOICE{ -- proximity diagnostics: + resultSets [1] IMPLICIT NULL, + -- proximity between sets not + -- supported + badSet [2] IMPLICIT InternationalString, + -- bad result set specified + relation [3] IMPLICIT INTEGER, + -- 1 to 6 ; relation not supported + unit [4] IMPLICIT INTEGER, + -- unsupported unit code + distance [5] IMPLICIT INTEGER, + -- unsupported distance + attributes [6] AttributeList, + -- proximity not supported with + -- specified attribute combination + ordered [7] IMPLICIT NULL, + -- ordered flag not supported + exclusion [8] IMPLICIT NULL + -- exclusion flag not supported + }, + + +scan [1008] CHOICE{ -- scan diagnostics: + nonZeroStepSize [0] IMPLICIT NULL, + -- only zero step size + -- supported + specifiedStepSize [1] IMPLICIT NULL, + -- specified step size not + -- supported + termList1 [3] IMPLICIT NULL, + -- term list not supported + -- (no alternative supplied) + termList2 [4] IMPLICIT SEQUENCE OF + AttributeList, + -- term list not supported + -- (alternatives supplied) + posInResponse [5] IMPLICIT INTEGER{ + -- value of positionIn- + -- Response not supported + mustBeOne (1), + mustBePositive (2), + mustBeNonNegative (3), + other (4)}, + resources [6] IMPLICIT NULL, + -- resources exhausted + -- looking for satisfying + -- terms + endOfList [7] IMPLICIT NULL + -- beginning or end of term + -- list + }, + + +sort [1009] CHOICE{ + sequence [0] IMPLICIT NULL, + -- cannot sort according + -- to sequence + noRsName [1] IMPLICIT NULL, + -- no result set name + -- supplied + tooMany [2] IMPLICIT INTEGER, + -- Too many input result + -- sets, maximum supplied. + incompatible [3] IMPLICIT NULL, + -- records with different + -- formats not compatible for + -- sorting + generic [4] IMPLICIT NULL, + -- generic sort not supported + -- (db specific only) + dbSpecific [5] IMPLICIT NULL, + -- db specific sort not + -- supported + sortElement [6] SortElement, + key [7] IMPLICIT INTEGER{ + tooMany (1), + -- too many sort keys + duplicate (2)}, + -- duplicate sort keys + action [8] IMPLICIT NULL, + -- unuspported missing data + -- action + illegal [9] IMPLICIT INTEGER{ + relation (1), + -- illegal sort relation + case (2), + -- illegal case value + action (3), + -- illegal missing data + -- action + sort (4)}, + -- illegal sort + inputTooLarge [10] IMPLICIT SEQUENCE OF + InternationalString, + -- one or more of the + -- input result sets too + -- large to sort + aggregateTooLarge [11] IMPLICIT NULL + -- aggregate result set + -- too large + }, +segmentation [1010] CHOICE{ + segmentCount [0] IMPLICIT NULL, + -- Cannot guarantee record will fit + -- within max segments. Target + -- suggests that origin try again + -- to retrieve record, without + -- including max-segment-count. + segmentSize [1] IMPLICIT INTEGER + -- record cannot be segmented into + -- fragments such that the largest + -- will fit within max segment + -- size specified. Target supplies (in + -- bytes) the smallest acceptable value. + -- of Max-segment-size to retrieve + -- the record. + }, + +extServices [1011] CHOICE{ + req [1] IMPLICIT INTEGER{ -- bad request + nameInUse (1), + -- package name already in use + noSuchName (2), + -- no such package, on + -- modify/delete + quota (3), + -- quota exceeded + type (4)}, + -- extended service type not + -- supported + permission [2] IMPLICIT INTEGER{ + -- permission denied on ES, because: + id (1), + -- id not authorized, or + modifyDelete (2)}, + -- cannot modify or delete + immediate [3] IMPLICIT INTEGER{ + -- immediate execution: + failed (1), + service (2), + -- not supported for this service, + parameters (3) + -- not supported for these + -- parameters. + }}, + + +accessCtrl [1012] CHOICE{ + noUser [1] IMPLICIT NULL, + -- no user to display challenge to + refused [2] IMPLICIT NULL, + -- access control information + -- refused by user + simple [3] IMPLICIT NULL, + -- only simple form supported + -- (target used externally defined) + oid [4] IMPLICIT SEQUENCE OF OBJECT + IDENTIFIER, + -- oid not supported (origin + -- supplies alternative suggested + -- oids) + alternative [5] IMPLICIT SEQUENCE OF OBJECT + IDENTIFIER, + -- origin insists that target use + -- an alternative challenge for + -- this data (e.g. stronger + -- authentication or stronger + -- Access control). The origin + -- supplies suggested alternative + -- oids. + pwdInv [6] IMPLICIT NULL, + -- password invalid + pwdExp [7] IMPLICIT NULL + -- password expired + }, + + +recordSyntax [1013] IMPLICIT SEQUENCE{ + -- record cannot be transferred in requested syntax + unsupportedSyntax [1] IMPLICIT OBJECT + IDENTIFIER, + suggestedAlternatives [2] IMPLICIT SEQUENCE OF + OBJECT IDENTIFIER + OPTIONAL} +} +END + +RecordSyntax-explain +{z39-50-recordSyntax explain (100)} DEFINITIONS ::= + +BEGIN +IMPORTS AttributeSetId, Term, OtherInformation, DatabaseName, ElementSetName, +IntUnit, Unit, StringOrNumeric, Specification, +InternationalString, +AttributeList, AttributeElement +FROM Z39-50-APDU-1995; + +Explain-Record ::= CHOICE{ + -- Each of these may be used as search term + -- when Use attribute is 'explain-category'. + targetInfo [0] IMPLICIT TargetInfo, + databaseInfo [1] IMPLICIT DatabaseInfo, + schemaInfo [2] IMPLICIT SchemaInfo, + tagSetInfo [3] IMPLICIT TagSetInfo, + recordSyntaxInfo [4] IMPLICIT RecordSyntaxInfo, + attributeSetInfo [5] IMPLICIT AttributeSetInfo, + termListInfo [6] IMPLICIT TermListInfo, + extendedServicesInfo [7] IMPLICIT ExtendedServicesInfo, + attributeDetails [8] IMPLICIT AttributeDetails, + termListDetails [9] IMPLICIT TermListDetails, + elementSetDetails [10] IMPLICIT ElementSetDetails, + retrievalRecordDetails [11] IMPLICIT RetrievalRecordDetails, + sortDetails [12] IMPLICIT SortDetails, + processing [13] IMPLICIT ProcessingInformation, + variants [14] IMPLICIT VariantSetInfo, + units [15] IMPLICIT UnitInfo, + categoryList [100] IMPLICIT CategoryList} + +-- Element set name 'B' (brief) retrieves: +-- - 'commonInfo' (except for otherInfo within commonInfo) +-- - key elements +-- - other elements designated as 'non-key brief elements' +-- Esn 'description' retrieves brief elements as well as 'description', and +-- specific additional descriptive elements if designated. +-- Element set name 'F' (full) retrieves all of the above, as well as those +-- designated as "non-brief elements". Some elements designated as OPTIONAL +-- may be madatory in full records, and are so identified. (Note that all +-- elements that are not part of the brief element set must be designated as +-- OPTIONAL in the ASN.1, otherwise it would be illegal to omit them). +-- Other esns are defined (below) as needed. + + +-- - - - - - - - - - - - - Info Records + -- Info records are mainly for software consumption + -- They describe individual entities within the target system: + -- The target itself + -- Individual databases + -- Schemas + -- Tag sets + -- Record syntaxes + -- Attribute sets + -- Term lists + -- Extended services + -- The information about each Schema, Tag Set, Record Syntax and Attribute + -- Set should match the universal definitions of these items. The only + -- exception is that a target may omit any- items it doesn't support, for + -- example the description of the BIB-1 attribute set may omit attributes + -- that the target does not support under any circumstances. + -- Databases that may be searched together can be listed in the + -- dbCominations element of the TargetInfo record. + + + +TargetInfo ::= SEQUENCE { + commonInfo [0] IMPLICIT CommonInfo OPTIONAL, + -- Key elements follow: + name [1] IMPLICIT InternationalString, + -- Non-key brief elements follow: + recent-news [2] IMPLICIT HumanString OPTIONAL, + icon [3] IMPLICIT IconObject OPTIONAL, + namedResultSets [4] IMPLICIT BOOLEAN, + multipleDBsearch [5] IMPLICIT BOOLEAN, + maxResultSets [6] IMPLICIT INTEGER OPTIONAL, + maxResultSize [7] IMPLICIT INTEGER OPTIONAL, + maxTerms [8] IMPLICIT INTEGER OPTIONAL, + timeoutInterval [9] IMPLICIT IntUnit OPTIONAL, + welcomeMessage [10] IMPLICIT HumanString OPTIONAL, + -- non-brief elements follow: + -- 'description' esn retrieves the following two (as well as brief): + contactInfo [11] IMPLICIT ContactInfo OPTIONAL, + description [12] IMPLICIT HumanString OPTIONAL, + nicknames [13] IMPLICIT SEQUENCE OF InternationalString + OPTIONAL, + usage-restrictions [14] IMPLICIT HumanString OPTIONAL, + paymentAddr [15] IMPLICIT HumanString OPTIONAL, + hours [16] IMPLICIT HumanString OPTIONAL, + dbCombinations [17] IMPLICIT SEQUENCE OF DatabaseList OPTIONAL, + addresses [18] IMPLICIT SEQUENCE OF NetworkAddress OPTIONAL, + languages [101] IMPLICIT SEQUENCE OF InternationalString OPTIONAL, + -- Languages supported for message strings. Each is a three-character + -- language code from Z39.53-1994. +-- characterSets [102] this tag reserved for "character sets supported for name and message strings". + + -- commonAccessInfo elements list objects the target supports. All objects + -- listed in AccessInfo for any individual database should also be listed + -- here. + commonAccessInfo [19] IMPLICIT AccessInfo OPTIONAL} +-- + + +DatabaseInfo ::= SEQUENCE { + -- A target may provide "virtual databases" that are combinations of + -- individual database. These databases are indicated by the + -- presence of subDbs in the combination database's + -- DatabaseDescription. + commonInfo [0] IMPLICIT CommonInfo OPTIONAL, + -- Key elements follow: + name [1] IMPLICIT DatabaseName, + -- Non-key brief elements follow: + explainDatabase [2] IMPLICIT NULL OPTIONAL, + -- If present, this database is the Explain + -- database, or an Explain database + -- for a different server, + -- possibly on a different host. The means + -- by which that server may be accessed is + -- not addressed by this standard. One + -- suggested possibility is an implementor + -- agreement whereby the database name is a + -- url which may be used to connect to the + -- server. + nicknames [3] IMPLICIT SEQUENCE OF DatabaseName OPTIONAL, + icon [4] IMPLICIT IconObject OPTIONAL, + user-fee [5] IMPLICIT BOOLEAN, + available [6] IMPLICIT BOOLEAN, + titleString [7] IMPLICIT HumanString OPTIONAL, + -- Non-brief elements follow: + keywords [8] IMPLICIT SEQUENCE OF HumanString OPTIONAL, + description [9] IMPLICIT HumanString OPTIONAL, + associatedDbs [10] IMPLICIT DatabaseList OPTIONAL, + -- databases that may be searched in + -- combination with this one + subDbs [11] IMPLICIT DatabaseList OPTIONAL, + -- When present, this database is a + -- composite representing the combined + -- databases 'subDbs'. The individual subDbs + -- are also available. + disclaimers [12] IMPLICIT HumanString OPTIONAL, + news [13] IMPLICIT HumanString OPTIONAL, + recordCount [14] CHOICE { + actualNumber [0] IMPLICIT INTEGER, + approxNumber [1] IMPLICIT INTEGER} + OPTIONAL, + defaultOrder [15] IMPLICIT HumanString OPTIONAL, + avRecordSize [16] IMPLICIT INTEGER OPTIONAL, + maxRecordSize [17] IMPLICIT INTEGER OPTIONAL, + hours [18] IMPLICIT HumanString OPTIONAL, + bestTime [19] IMPLICIT HumanString OPTIONAL, + lastUpdate [20] IMPLICIT GeneralizedTime OPTIONAL, + updateInterval [21] IMPLICIT IntUnit OPTIONAL, + coverage [22] IMPLICIT HumanString OPTIONAL, + proprietary [23] IMPLICIT BOOLEAN OPTIONAL, + -- mandatory in full record + copyrightText [24] IMPLICIT HumanString OPTIONAL, + copyrightNotice [25] IMPLICIT HumanString OPTIONAL, + producerContactInfo [26] IMPLICIT ContactInfo OPTIONAL, + supplierContactInfo [27] IMPLICIT ContactInfo OPTIONAL, + submissionContactInfo [28] IMPLICIT ContactInfo OPTIONAL, + -- accessInfo lists items connected with the database. All listed items + -- should be in the target's AccessInfo. + accessInfo [29] IMPLICIT AccessInfo OPTIONAL} + + + +SchemaInfo ::= SEQUENCE { + commonInfo [0] IMPLICIT CommonInfo OPTIONAL, + -- Key elements follow: + schema [1] IMPLICIT OBJECT IDENTIFIER, + -- Non-key brief elements follow: + name [2] IMPLICIT InternationalString, + -- Non-brief elements follow: + description [3] IMPLICIT HumanString OPTIONAL, + tagTypeMapping [4] IMPLICIT SEQUENCE OF SEQUENCE { + tagType [0] IMPLICIT INTEGER, + tagSet [1] IMPLICIT OBJECT IDENTIFIER + OPTIONAL, + -- If tagSet is omitted, then + -- this tagType is for a tagSet + -- locally defined within the + -- schema that cannot be + -- referenced by another schema. + defaultTagType [2] IMPLICIT NULL OPTIONAL} OPTIONAL, + recordStructure [5] IMPLICIT SEQUENCE OF ElementInfo OPTIONAL} + + + + -- ElementInfo referenced in SchemaInfo and RecordSyntaxInfo + ElementInfo ::= SEQUENCE { + elementName [1] IMPLICIT InternationalString, + elementTagPath [2] IMPLICIT Path, + dataType [3] ElementDataType OPTIONAL, + -- If omitted, not specified. + required [4] IMPLICIT BOOLEAN, + repeatable [5] IMPLICIT BOOLEAN, + description [6] IMPLICIT HumanString OPTIONAL} + + -- Path is referenced by ElementInfo as well as PerElementDetails + Path ::= SEQUENCE OF SEQUENCE{ + tagType [1] IMPLICIT INTEGER, + tagValue [2] StringOrNumeric} + + ElementDataType ::= CHOICE{ + primitive [0] IMPLICIT PrimitiveDataType, + structured [1] IMPLICIT SEQUENCE OF ElementInfo} + PrimitiveDataType ::= INTEGER{ + octetString (0), + numeric (1), + date (2), + external (3), + string (4), + trueOrFalse (5), + oid (6), + intUnit (7), + empty (8), + noneOfTheAbove (100) -- see 'description' + } + + +TagSetInfo ::= SEQUENCE { + commonInfo [0] IMPLICIT CommonInfo OPTIONAL, + -- Key elements follow: + tagSet [1] IMPLICIT OBJECT IDENTIFIER, + -- non-key brief elements follow: + name [2] IMPLICIT InternationalString, + -- non-brief elements follow: + description [3] IMPLICIT HumanString OPTIONAL, + elements [4] IMPLICIT SEQUENCE OF SEQUENCE { + elementname [1] IMPLICIT InternationalString, + nicknames [2] IMPLICIT SEQUENCE OF + InternationalString OPTIONAL, + elementTag [3] StringOrNumeric, + description [4] IMPLICIT HumanString OPTIONAL, + dataType [5] PrimitiveDataType OPTIONAL, + -- If the data type is expected + -- to be structured, that is + -- described in the schema info, + -- and datatypeis omitted here. + otherTagInfo OtherInformation OPTIONAL} OPTIONAL} + + + +RecordSyntaxInfo ::= SEQUENCE { + commonInfo [0] IMPLICIT CommonInfo OPTIONAL, + -- Key elements follow: + recordSyntax [1] IMPLICIT OBJECT IDENTIFIER, + -- Non-key brief elements follow: + name [2] IMPLICIT InternationalString, + -- non-brief elements follow: + transferSyntaxes [3] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL, + description [4] IMPLICIT HumanString OPTIONAL, + asn1Module [5] IMPLICIT InternationalString OPTIONAL, + abstractStructure [6] IMPLICIT SEQUENCE OF ElementInfo OPTIONAL + -- Omitting abstractStructure only means target + -- isn't using Explain to describe the structure, + -- not that there is no structure. + } + + + +AttributeSetInfo ::= SEQUENCE { + commonInfo [0] IMPLICIT CommonInfo OPTIONAL, + -- Key elements follow: + attributeSet [1] IMPLICIT AttributeSetId, + -- non-key brief elements follow: + name [2] IMPLICIT InternationalString, + -- non-brief elements follow: + attributes [3] IMPLICIT SEQUENCE OF AttributeType OPTIONAL, + -- mandatory in full record + description [4] IMPLICIT HumanString OPTIONAL} + + + +-- AttributeType referenced in AttributeSetInfo + AttributeType ::= SEQUENCE { + name [0] IMPLICIT InternationalString OPTIONAL, + description [1] IMPLICIT HumanString OPTIONAL, + attributeType [2] IMPLICIT INTEGER, + attributeValues [3] IMPLICIT SEQUENCE OF AttributeDescription} + + AttributeDescription ::= SEQUENCE { + name [0] IMPLICIT InternationalString OPTIONAL, + description [1] IMPLICIT HumanString OPTIONAL, + attributeValue [2] StringOrNumeric, + equivalentAttributes [3] IMPLICIT SEQUENCE OF StringOrNumeric + OPTIONAL + -- each is an occurence of + -- 'attributeValue' from + --AttributeDescription for a + -- different attribute. Equivalences + -- listed here should be derived from the + -- attribute set definition, not from a + -- particular server's behavior. + } + + +TermListInfo ::= SEQUENCE{ + commonInfo [0] IMPLICIT CommonInfo OPTIONAL, + -- Key elements follow: + databaseName [1] IMPLICIT DatabaseName, + -- Non-key brief elements follow: + termLists [2] IMPLICIT SEQUENCE OF SEQUENCE{ + name [1] IMPLICIT InternationalString, + title [2] IMPLICIT HumanString OPTIONAL, + -- Title is for users to see + -- and can differ by language. + -- Name, on the other hand, is + -- typically a short string + -- not necessarily meant to be + -- human-readable, and not + -- variable by language. + searchCost [3] IMPLICIT INTEGER { + optimized (0), + -- The attribute (or combination) + -- associated with this list will + -- do fast searches. + normal (1), + -- The attribute (combination) will + -- work expected. So there's + -- probably an index for the + -- attribute (combination) or some + -- similar mechanism. + expensive (2), + -- Can use the attribute + -- (combination), but it might not + -- provide satisfactory results. + -- Probably there is no index, or + -- post-processing of records is + -- required. + filter (3) + -- can't search with this + -- attribute (combination) alone. + } OPTIONAL, + scanable [4] IMPLICIT BOOLEAN, + -- 'true' means this list can be + -- scanned. + broader [5] IMPLICIT SEQUENCE OF InternationalString + OPTIONAL, + narrower [6] IMPLICIT SEQUENCE OF InternationalString + OPTIONAL + -- broader and narrower list + -- alternative term lists related to + -- this one. The term lists so listed + -- should also be in this termLists + -- structure. + } + -- no non-brief elements + } + + + + +ExtendedServicesInfo ::= SEQUENCE { + commonInfo [0] IMPLICIT CommonInfo OPTIONAL, + -- Key elements follow: + type [1] IMPLICIT OBJECT IDENTIFIER, + -- Non-key brief elements follow: + name [2] IMPLICIT InternationalString OPTIONAL, + -- should be supplied if privateType is 'true' + privateType [3] IMPLICIT BOOLEAN, + restrictionsApply [5] IMPLICIT BOOLEAN, -- if 'true' see 'description' + feeApply [6] IMPLICIT BOOLEAN, -- if 'true' see 'description' + available [7] IMPLICIT BOOLEAN, + retentionSupported [8] IMPLICIT BOOLEAN, + waitAction [9] IMPLICIT INTEGER{ + waitSupported (1), + waitAlways (2), + waitNotSupported (3), + depends (4), + notSaying (5)}, + -- non-brief elements follow: + -- To get brief plus 'description' use esn 'description' + description [10] IMPLICIT HumanString OPTIONAL, + -- to get above elements and 'specificExplain' use esn + --'specificExplain' + specificExplain [11] IMPLICIT EXTERNAL OPTIONAL, + -- Use oid of specific ES, and select choice + -- [3] 'explain'. Format to be developed in + -- conjunction with the specific ES definition. + -- to get all elements except 'specificExplain', use esn 'asn' + esASN [12] IMPLICIT InternationalString OPTIONAL + -- the ASN.1 for this ES + } + +-- - - - - - - - - - - - - Detail records + -- The detail records describe relationships among entities supported by the + -- target. RetrievalRecordDetails describes the way that schema elements are + -- mapped into record elements. This mapping may be different for each + -- combination of database, schema, record syntax. The per-element details + -- describe the default mapping. Origin-request re-tagging can change that + -- mapping. When multiple databases are listed in a databaseNames element, + -- the record applies equally to all of the listed databases. This is + -- unrelated to searching the databases together. AttributeDetails describes + -- how databases can be searched. Each supported attribute is listed, and + -- the allowable combinations can be described. + +AttributeDetails ::= SEQUENCE { + commonInfo [0] IMPLICIT CommonInfo OPTIONAL, + -- Key elements follow: + databaseName [1] IMPLICIT DatabaseName, + -- Non-brief elements follow: + attributesBySet [2] IMPLICIT SEQUENCE OF AttributeSetDetails + OPTIONAL, + -- mandatory in full record + attributeCombinations [3] IMPLICIT AttributeCombinations OPTIONAL} + + +-- AttributeSetDetails referenced by AttributeDetails + AttributeSetDetails ::= SEQUENCE { + attributeSet [0] IMPLICIT AttributeSetId, + attributesByType [1] IMPLICIT SEQUENCE OF AttributeTypeDetails} + + + AttributeTypeDetails ::= SEQUENCE { + attributeType [0] IMPLICIT INTEGER, + defaultIfOmitted [1] IMPLICIT OmittedAttributeInterpretation OPTIONAL, + attributeValues [2] IMPLICIT SEQUENCE OF AttributeValue OPTIONAL } + -- If no attributeValues are supplied, all + -- values of this type are fully supported, and + -- the descriptions in AttributeSetInfo are + -- adequate. + + + OmittedAttributeInterpretation ::= +SEQUENCE { + defaultValue [0] StringOrNumeric OPTIONAL, + -- A default value is listed if that's how + -- the server works + defaultDescription [1] IMPLICIT HumanString OPTIONAL } + -- The human-readable description should + -- generally be provided. It is legal for + -- both default elements to be missing, + -- which means that the target will allow + -- the attribute type to be omitted, but + -- isn't saying what it will do. + +AttributeValue ::= SEQUENCE { + value [0] StringOrNumeric, + description [1] IMPLICIT HumanString OPTIONAL, + subAttributes [2] IMPLICIT SEQUENCE OF StringOrNumeric OPTIONAL, + superAttributes [3] IMPLICIT SEQUENCE OF StringOrNumeric OPTIONAL, + partialSupport [4] IMPLICIT NULL OPTIONAL + -- partialSupport indicates that an attributeValue is + -- accepted, but may not be processed in the + -- "expected" way. One important reason for this is + -- composite databases: in this case partialSupport + -- may indicate that only some of the subDbs support + -- the attribute, and others ignore it. + } + + +TermListDetails ::= SEQUENCE{ -- one for each termList in TermListInfo + commonInfo [0] IMPLICIT CommonInfo OPTIONAL, + -- Key elements follow: + termListName [1] IMPLICIT InternationalString, + -- Non-key elements (all non-brief) follow: + description [2] IMPLICIT HumanString OPTIONAL, + attributes [3] IMPLICIT AttributeCombinations OPTIONAL, + -- Pattern for attributes that hit this list. + -- Mandatory in full record + scanInfo [4] IMPLICIT SEQUENCE { + maxStepSize [0] IMPLICIT INTEGER OPTIONAL, + collatingSequence [1] IMPLICIT HumanString OPTIONAL, + increasing [2] IMPLICIT BOOLEAN OPTIONAL} + OPTIONAL, + -- Occurs only if list is scanable. + -- If list is scanable and if scanInfo is omitted, + -- target doesn't consider these important. + estNumberTerms [5] IMPLICIT INTEGER OPTIONAL, + sampleTerms [6] IMPLICIT SEQUENCE OF Term OPTIONAL} + + + +ElementSetDetails ::= SEQUENCE { + -- ElementSetDetails describes the way that database records are mapped to + -- record elements. This mapping may be different for each combination of + -- database name and element set. The database record description is a + -- schema, which may be private to the target. The schema's abstract + -- record structure and tag sets provide the vocabulary for discussing + -- record content; their presence in the Explain database does not imply + -- support for complex retrieval specification. + commonInfo [0] IMPLICIT CommonInfo OPTIONAL, + -- Key elements follow: + databaseName [1] IMPLICIT DatabaseName, + elementSetName [2] IMPLICIT ElementSetName, + recordSyntax [3] IMPLICIT OBJECT IDENTIFIER, + -- Non-key Brief elements follow: + schema [4] IMPLICIT OBJECT IDENTIFIER, + -- Non-brief elements follow: + description [5] IMPLICIT HumanString OPTIONAL, + detailsPerElement [6] IMPLICIT SEQUENCE OF PerElementDetails OPTIONAL + -- mandatory in full record + } + + + +RetrievalRecordDetails ::= SEQUENCE { + commonInfo [0] IMPLICIT CommonInfo OPTIONAL, + -- Key elements follow: + databaseName [1] IMPLICIT DatabaseName, + schema [2] IMPLICIT OBJECT IDENTIFIER, + recordSyntax [3] IMPLICIT OBJECT IDENTIFIER, + -- Non-brief elements follow: + description [4] IMPLICIT HumanString OPTIONAL, + detailsPerElement [5] IMPLICIT SEQUENCE OF PerElementDetails OPTIONAL + -- mandatory in full record + } + + + +-- PerElementDetails is referenced in RetreivalRecordDetails and +-- ElementSetDetails. + PerElementDetails ::= SEQUENCE { + name [0] IMPLICIT InternationalString OPTIONAL, + -- If the name is omitted, the record + -- syntax's name for this element is + -- appropriate. + recordTag [1] IMPLICIT RecordTag OPTIONAL, + -- The record tag may be omitted if tags are + -- inappropriate for the syntax, or if the + -- origin can be expected to know it for + -- some other reason. + schemaTags [2] IMPLICIT SEQUENCE OF Path OPTIONAL, + -- The information from the listed schema + -- elements is in some way to produce the + -- data sent in the listed record tag. The + -- 'contents' element below may describe the + -- the logic used. + maxSize [3] IMPLICIT INTEGER OPTIONAL, + minSize [4] IMPLICIT INTEGER OPTIONAL, + avgSize [5] IMPLICIT INTEGER OPTIONAL, + fixedSize [6] IMPLICIT INTEGER OPTIONAL, + repeatable [8] IMPLICIT BOOLEAN, + required [9] IMPLICIT BOOLEAN, + -- 'required' really means that target will + -- always supply the element. + description [12] IMPLICIT HumanString OPTIONAL, + contents [13] IMPLICIT HumanString OPTIONAL, + billingInfo [14] IMPLICIT HumanString OPTIONAL, + restrictions [15] IMPLICIT HumanString OPTIONAL, + alternateNames [16] IMPLICIT SEQUENCE OF InternationalString + OPTIONAL, + genericNames [17] IMPLICIT SEQUENCE OF InternationalString + OPTIONAL, + searchAccess [18] IMPLICIT AttributeCombinations OPTIONAL} + + -- RecordTag referenced in PerElementDetails above + RecordTag ::= SEQUENCE { + qualifier [0] StringOrNumeric OPTIONAL, + -- E.g. tag set for GRS-1 + tagValue [1] StringOrNumeric} + + + + +SortDetails ::= SEQUENCE { + commonInfo [0] IMPLICIT CommonInfo OPTIONAL, + -- Key elements follow: + databaseName [1] IMPLICIT DatabaseName, + -- No non-key brief elements + -- Non-brief elements follow: + sortKeys [2] IMPLICIT SEQUENCE OF SortKeyDetails OPTIONAL + -- mandatory in full record + } + + SortKeyDetails ::= SEQUENCE { + description [0] IMPLICIT HumanString OPTIONAL, + elementSpecifications [1] IMPLICIT SEQUENCE OF Specification + OPTIONAL, + -- each specification is a way of + -- specifying this same sort key + attributeSpecifications [2] IMPLICIT AttributeCombinations OPTIONAL, + -- each combination is a way of + -- specifying this same sort key + sortType [3] CHOICE { + character [0] IMPLICIT NULL, + numeric [1] IMPLICIT NULL, + structured [2] IMPLICIT + HumanString} OPTIONAL, + caseSensitivity [4] IMPLICIT INTEGER { + always (0), + -- always case-sensitive + never (1), + -- never case-sensitive + default-yes (2), + -- case-sensitivity is as specified + -- on request, and if not + -- specified, case-sensitive. + default-no (3) + -- case-sensitivity is as specified + -- on request, and if not + -- specified, not case-sensitive. + } + OPTIONAL} + + + +ProcessingInformation ::= SEQUENCE{ + commonInfo [0] IMPLICIT CommonInfo OPTIONAL, + -- Key elements follow: + databaseName [1] IMPLICIT DatabaseName, + processingContext [2] IMPLICIT INTEGER { + access (0), + -- e.g. choosing databases + search (1), + -- e.g. "search strategies" or search forms + retrieval (2), + -- e.g. recommended element combinations + record-presentation (3), + -- display of retrieved records + record-handling (4) + -- handling (e.g. saving) of retrieved + -- records + }, + name [3] IMPLICIT InternationalString, + oid [4] IMPLICIT OBJECT IDENTIFIER, + -- So origin can retreive brief record and + -- determine if it can handle 'instructions' when + -- retrieving the full record. + -- No non-key brief elements + -- Non-brief elements follow: + description [5] IMPLICIT HumanString OPTIONAL, + -- use element set name 'description' + -- to retrieve all except instructions. + instructions [6] IMPLICIT EXTERNAL OPTIONAL -- mandatory in full record + } + + + + +VariantSetInfo ::= SEQUENCE { + -- A record in this category describes a variant set definition, i.e., + -- classes, types, and values, for a specific variant set definition + -- supported by the target. Support by the target of a particular + -- variant set definition does not imply that the definition is + -- supported for any specific database or element. + commonInfo [0] IMPLICIT CommonInfo OPTIONAL, + -- Key elements follow: + variantSet [1] IMPLICIT OBJECT IDENTIFIER, + -- Non-key brief elements follow: + name [2] IMPLICIT InternationalString, + -- Non-brief elements follow: + variants [3] IMPLICIT SEQUENCE OF VariantClass OPTIONAL + -- mandatory in full record + } + + -- Subsidiary structures for VariantSetInfo + VariantClass ::= SEQUENCE { + name [0] IMPLICIT InternationalString OPTIONAL, + description [1] IMPLICIT HumanString OPTIONAL, + variantClass [2] IMPLICIT INTEGER, + variantTypes [3] IMPLICIT SEQUENCE OF VariantType} + + VariantType ::= SEQUENCE { + name [0] IMPLICIT InternationalString OPTIONAL, + description [1] IMPLICIT HumanString OPTIONAL, + variantType [2] IMPLICIT INTEGER, + variantValue [3] IMPLICIT VariantValue OPTIONAL} + + VariantValue ::= SEQUENCE { + dataType [0] PrimitiveDataType, + values [1] ValueSet OPTIONAL } + + ValueSet ::= CHOICE { + range [0] IMPLICIT ValueRange, + enumerated [1] IMPLICIT SEQUENCE OF ValueDescription } + + ValueRange ::= SEQUENCE { + -- At last one the following must be supplied, both + -- may be supplied. + lower [0] ValueDescription OPTIONAL, + upper [1] ValueDescription OPTIONAL } + + ValueDescription ::= CHOICE{ + integer INTEGER, + string InternationalString, + octets OCTET STRING, + oid OBJECT IDENTIFIER, + unit [1] IMPLICIT Unit, + valueAndUnit [2] IMPLICIT IntUnit + -- oid and unit can't be used in a ValueRange + } + + + +UnitInfo ::= SEQUENCE { + commonInfo [0] IMPLICIT CommonInfo OPTIONAL, + -- Key elements follow: + unitSystem [1] IMPLICIT InternationalString, + -- No non-key brief elements + -- Non-brief elements follow: + description [2] IMPLICIT HumanString OPTIONAL, + units [3] IMPLICIT SEQUENCE OF UnitType OPTIONAL } + -- mandatory in full record + + -- Subsidiary structures for UnitInfo + UnitType ::= SEQUENCE { + name [0] IMPLICIT InternationalString OPTIONAL, + description [1] IMPLICIT HumanString OPTIONAL, + unitType [2] StringOrNumeric, + units [3] IMPLICIT SEQUENCE OF Units} + + Units ::= SEQUENCE { + name [0] IMPLICIT InternationalString OPTIONAL, + description [1] IMPLICIT HumanString OPTIONAL, + unit [2] StringOrNumeric} + + + +CategoryList ::= SEQUENCE { + commonInfo [0] IMPLICIT CommonInfo OPTIONAL, + -- Only one record expected per Explain database. All elements + -- appear in brief presentation. + categories [1] IMPLICIT SEQUENCE OF CategoryInfo } + + CategoryInfo ::= SEQUENCE { + category [1] IMPLICIT InternationalString, + originalCategory [2] IMPLICIT InternationalString OPTIONAL, + description [3] IMPLICIT HumanString OPTIONAL, + asn1Module [4] IMPLICIT InternationalString OPTIONAL} + + + + +-- - - - - - - - - - - - - - Subsidiary definitions + +CommonInfo ::= SEQUENCE { + dateAdded [0] IMPLICIT GeneralizedTime OPTIONAL, + dateChanged [1] IMPLICIT GeneralizedTime OPTIONAL, + expiry [2] IMPLICIT GeneralizedTime OPTIONAL, + humanString-Language [3] IMPLICIT LanguageCode OPTIONAL, + -- following not to occur for brief: + otherInfo OtherInformation OPTIONAL} + +HumanString ::= SEQUENCE OF SEQUENCE { + language [0] IMPLICIT LanguageCode OPTIONAL, + text [1] IMPLICIT InternationalString} + +IconObject ::= SEQUENCE OF SEQUENCE{ + -- Note that the "SEQUENCE OF" is to allow alternative + -- representations of the same Icon; it is not intended to allow + -- multiple icons. + bodyType [1] CHOICE{ + ianaType [1] IMPLICIT InternationalString, + z3950type [2] IMPLICIT InternationalString, + otherType [3] IMPLICIT InternationalString}, + content [2] IMPLICIT OCTET STRING} + + +LanguageCode ::=InternationalString + -- from ANSI/NISO Z39.53-1994 + +ContactInfo ::= SEQUENCE { + name [0] IMPLICIT InternationalString OPTIONAL, + description [1] IMPLICIT HumanString OPTIONAL, + address [2] IMPLICIT HumanString OPTIONAL, + email [3] IMPLICIT InternationalString OPTIONAL, + phone [4] IMPLICIT InternationalString OPTIONAL} + +NetworkAddress ::= CHOICE { + internetAddress [0] IMPLICIT SEQUENCE { + hostAddress [0] IMPLICIT + InternationalString, + port [1] IMPLICIT INTEGER}, + osiPresentationAddress [1] IMPLICIT SEQUENCE { + pSel [0] IMPLICIT InternationalString, + sSel [1] IMPLICIT InternationalString + OPTIONAL, + tSel [2] IMPLICIT InternationalString + OPTIONAL, + nSap [3] IMPLICIT InternationalString}, + other [2] IMPLICIT SEQUENCE { + type [0] IMPLICIT InternationalString, + address [1] IMPLICIT InternationalString}} + + +AccessInfo ::= SEQUENCE { + -- AccessInfo contains the fundmental information about what facilites + -- are required to use this target or server. For example, if an origin + -- can handle none of the record syntaxes a database can provide, + -- it might choose not to access the database. + queryTypesSupported [0] IMPLICIT SEQUENCE OF QueryTypeDetails OPTIONAL, + diagnosticsSets [1] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL, + attributeSetIds [2] IMPLICIT SEQUENCE OF AttributeSetId OPTIONAL, + schemas [3] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL, + recordSyntaxes [4] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL, + resourceChallenges [5] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL, + restrictedAccess [6] IMPLICIT AccessRestrictions OPTIONAL, + costInfo [8] IMPLICIT Costs OPTIONAL, + variantSets [9] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL, + elementSetNames [10] IMPLICIT SEQUENCE OF ElementSetName OPTIONAL, + unitSystems [11] IMPLICIT SEQUENCE OF InternationalString} + + +-- begin auxiliary definitions for AccessInfo +-- Begin Query Details +QueryTypeDetails ::= CHOICE { + private [0] IMPLICIT PrivateCapabilities, + rpn [1] IMPLICIT RpnCapabilities, + iso8777 [2] IMPLICIT Iso8777Capabilities, + z39-58 [100] IMPLICIT HumanString, + erpn [101] IMPLICIT RpnCapabilities, + rankedList [102] IMPLICIT HumanString} + + +PrivateCapabilities ::= SEQUENCE { + operators [0] IMPLICIT SEQUENCE OF SEQUENCE { + operator [0] IMPLICIT InternationalString, + description [1] IMPLICIT HumanString OPTIONAL } OPTIONAL, + searchKeys [1] IMPLICIT SEQUENCE OF SearchKey OPTIONAL, + -- field names that can be searched + description [2] IMPLICIT SEQUENCE OF HumanString OPTIONAL } + + +RpnCapabilities ::= SEQUENCE { + operators [0] IMPLICIT SEQUENCE OF INTEGER OPTIONAL, + -- Omitted means all operators are supported. + resultSetAsOperandSupported [1] IMPLICIT BOOLEAN, + restrictionOperandSupported [2] IMPLICIT BOOLEAN, + proximity [3] IMPLICIT ProximitySupport OPTIONAL} + +Iso8777Capabilities ::= SEQUENCE { + searchKeys [0] IMPLICIT SEQUENCE OF SearchKey, + -- field names that may be searched + restrictions [1] IMPLICIT HumanString OPTIONAL + -- Omitted means supported, not specifying units. + } + +ProximitySupport ::= SEQUENCE { + anySupport [0] IMPLICIT BOOLEAN, + -- 'false' means no proximity support, in which case + -- unitsSupported not supplied. + unitsSupported [1] IMPLICIT SEQUENCE OF CHOICE{ + known [1] IMPLICIT INTEGER, + -- values from KnownProximityUnit + private [2] IMPLICIT SEQUENCE{ + unit [0] IMPLICIT INTEGER, + description [1] HumanString OPTIONAL}} + OPTIONAL} + +SearchKey ::= SEQUENCE { + searchKey [0] IMPLICIT InternationalString, + description [1] IMPLICIT HumanString OPTIONAL } +-- End Query details + + + +AccessRestrictions ::= SEQUENCE OF SEQUENCE { + accessType [0] INTEGER { + any (0), + search (1), + present (2), + specific-elements (3), + extended-services (4), + by-database (5)}, + accessText [1] IMPLICIT HumanString OPTIONAL, + accessChallenges [2] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL} + + +Costs ::= SEQUENCE { + connectCharge [0] IMPLICIT Charge OPTIONAL, -- Per-connection charge + connectTime [1] IMPLICIT Charge OPTIONAL, -- Time-based charge + displayCharge [2] IMPLICIT Charge OPTIONAL, -- Per-record charge + searchCharge [3] IMPLICIT Charge OPTIONAL, -- Per-search charge + subscriptCharge [4] IMPLICIT Charge OPTIONAL, -- Subscription charges + otherCharges [5] IMPLICIT SEQUENCE OF SEQUENCE{ -- Other charges + forWhat [1] IMPLICIT HumanString, + charge [2] IMPLICIT Charge} OPTIONAL} + + Charge ::= SEQUENCE{ + cost [1] IMPLICIT IntUnit, + perWhat [2] IMPLICIT Unit OPTIONAL, + -- e.g. "second," "minute," "line," "record"... + text [3] IMPLICIT HumanString OPTIONAL} +-- End Auxiliary definitions for AccessInfo + + +DatabaseList ::= SEQUENCE OF DatabaseName + +AttributeCombinations ::= SEQUENCE { + defaultAttributeSet [0] IMPLICIT AttributeSetId, + -- Default for the combinations. Also probably + -- a good choice for the default + -- in searches, but that isn't required. + legalCombinations [1] IMPLICIT SEQUENCE OF AttributeCombination } + + +AttributeCombination ::= SEQUENCE OF AttributeOccurrence + -- An AttributeCombination is a pattern for legal combination of attributes + + +AttributeOccurrence ::= SEQUENCE { + -- An AttributeOccurrence lists the legal values for a + -- specific attribute type in a combination. + attributeSet [0] IMPLICIT AttributeSetId OPTIONAL, + attributeType [1] IMPLICIT INTEGER, + mustBeSupplied [2] IMPLICIT NULL OPTIONAL, + attributeValues CHOICE { + any-or-none [3] IMPLICIT NULL, + -- All supported values are OK + specific [4] IMPLICIT SEQUENCE OF + StringOrNumeric}} + -- Only these values allowed + + +END + + + + + +RecordSyntax-summary + +{z39-50-recordSyntax summary (103)} DEFINITIONS ::= +BEGIN +IMPORTS OtherInformation, InternationalString FROM Z39-50-APDU-1995; + +BriefBib ::= SEQUENCE { + title [1] IMPLICIT InternationalString, + author [2] IMPLICIT InternationalString OPTIONAL, + callNumber [3] IMPLICIT InternationalString OPTIONAL, + recordType [4] IMPLICIT InternationalString OPTIONAL, + bibliographicLevel [5] IMPLICIT InternationalString OPTIONAL, + format [6] IMPLICIT SEQUENCE OF FormatSpec OPTIONAL, + publicationPlace [7] IMPLICIT InternationalString OPTIONAL, + publicationDate [8] IMPLICIT InternationalString OPTIONAL, + targetSystemKey [9] IMPLICIT InternationalString OPTIONAL, + satisfyingElement [10] IMPLICIT InternationalString OPTIONAL, + rank [11] IMPLICIT INTEGER OPTIONAL, + documentId [12] IMPLICIT InternationalString OPTIONAL, + abstract [13] IMPLICIT InternationalString OPTIONAL, + otherInfo OtherInformation OPTIONAL} + + FormatSpec ::= SEQUENCE { + type [1] IMPLICIT InternationalString, + size [2] IMPLICIT INTEGER OPTIONAL, + bestPosn [3] IMPLICIT INTEGER OPTIONAL} +END + + + + + +RecordSyntax-generic -- For detailed semantics, see Appendix RET. +{z39-50-recordSyntax grs-1 (105)} DEFINITIONS ::= +BEGIN +EXPORTS Variant; +IMPORTS IntUnit, Unit, InternationalString, StringOrNumeric, Term +FROM Z39-50-APDU-1995; + +GenericRecord ::= SEQUENCE OF TaggedElement +TaggedElement ::= SEQUENCE { + tagType [1] IMPLICIT INTEGER OPTIONAL, + -- If omitted, default should be supplied dynamically + -- by tagSet-M; otherwise it should be statically + -- specified by the schema. + tagValue [2] StringOrNumeric, + tagOccurrence [3] IMPLICIT INTEGER OPTIONAL, + -- Occurrence within the database record, and + -- relative to the parent. No default; if omitted, + -- target not telling or it is irrelevant. + content [4] ElementData, + metaData [5] IMPLICIT ElementMetaData OPTIONAL, + appliedVariant [6] IMPLICIT Variant OPTIONAL} + +ElementData ::= CHOICE{ + octets OCTET STRING, + numeric INTEGER, + date GeneralizedTime, + ext EXTERNAL, + string InternationalString, + trueOrFalse BOOLEAN, + oid OBJECT IDENTIFIER, + intUnit [1] IMPLICIT IntUnit, + elementNotThere [2] IMPLICIT NULL, -- element requested but not there + elementEmpty [3] IMPLICIT NULL, -- element there, but empty + noDataRequested [4] IMPLICIT NULL, -- variant request said 'no data' + diagnostic [5] IMPLICIT EXTERNAL, + subtree [6] SEQUENCE OF TaggedElement + -- recursive, for nested tags + } + +ElementMetaData ::= SEQUENCE{ + seriesOrder [1] IMPLICIT Order OPTIONAL, + -- only for a non-leaf node + usageRight [2] IMPLICIT Usage OPTIONAL, + hits [3] IMPLICIT SEQUENCE OF HitVector OPTIONAL, + displayName [4] IMPLICIT InternationalString OPTIONAL, + -- name for element that origin can use for + -- display + supportedVariants [5] IMPLICIT SEQUENCE OF Variant OPTIONAL, + message [6] IMPLICIT InternationalString OPTIONAL, + elementDescriptor [7] IMPLICIT OCTET STRING OPTIONAL, + surrogateFor [8] IMPLICIT TagPath OPTIONAL, + -- the retrieved element is a surrogate for the + -- element given by this path + surrogateElement [9] IMPLICIT TagPath OPTIONAL, + -- the element given by this path is a + -- surrogate for the retrieved element + other [99] IMPLICIT EXTERNAL OPTIONAL} + + TagPath ::= SEQUENCE OF SEQUENCE{ + tagType [1] IMPLICIT INTEGER OPTIONAL, + tagValue [2] StringOrNumeric, + tagOccurrence [3] IMPLICIT INTEGER OPTIONAL} + + +Order ::= SEQUENCE{ + ascending [1] IMPLICIT BOOLEAN, + -- "true" means monotonically increasing (i.e. non- + -- decreasing); "false" means monotonically + -- decreasing (i.e. non-increasing). + order [2] IMPLICIT INTEGER + -- Same as defined by 'elementOrdering' in tagSet-M, + -- though this may be overidden by schema. + } + +Usage ::= SEQUENCE { + type [1] IMPLICIT INTEGER{ + redistributable (1), + -- Element is freely redistributable. + restricted (2), + -- Restriction contains statement. + licensePointer (3) + -- Restriction contains license pointer. + }, + restriction [2] IMPLICIT InternationalString OPTIONAL} + +HitVector ::= SEQUENCE{ + -- Each hit vector points to a fragment within the + -- element, via location and/or token. + satisfier Term OPTIONAL, -- sourceword, etc. + offsetIntoElement [1] IMPLICIT IntUnit OPTIONAL, + length [2] IMPLICIT IntUnit OPTIONAL, + hitRank [3] IMPLICIT INTEGER OPTIONAL, + targetToken [4] IMPLICIT OCTET STRING OPTIONAL + -- Origin may use token subsequently within a + -- variantRequest (in an elementRequest) to + -- retrieve (or to refer to) the fragment. + } + + +Variant ::= SEQUENCE{ + globalVariantSetId [1] IMPLICIT OBJECT IDENTIFIER OPTIONAL, + -- Applies to the triples below, when + -- variantSetId omitted. If + -- globalVariantSetId omitted, default applies. + -- Default may be provided by the tagSet-M + -- element defaultVariantSetId. + triples [2] IMPLICIT SEQUENCE OF SEQUENCE{ + variantSetId [0] IMPLICIT OBJECT IDENTIFIER + OPTIONAL, + -- If omitted, + -- globalVariantSetId + -- (above) applies, unless + -- that too is omitted, in + -- which case, default + -- used. + class [1] IMPLICIT INTEGER, + type [2] IMPLICIT INTEGER, + value [3] CHOICE{ + integer INTEGER, + string InternationalString, + octetString OCTET STRING, + oid OBJECT IDENTIFIER, + boolean BOOLEAN, + null NULL, + -- Following need context tags: + unit [1] IMPLICIT Unit, + valueAndUnit [2] IMPLICIT + IntUnit}}} +END + + +RecordSyntax-ESTaskPackage +{z39-50-recordSyntax esTaskPackage (106)} DEFINITIONS ::= +BEGIN +IMPORTS Permissions, InternationalString, IntUnit, DiagRec +FROM Z39-50-APDU-1995; + +TaskPackage ::= SEQUENCE{ + packageType [1] IMPLICIT OBJECT IDENTIFIER, + -- oid of specific ES definition + packageName [2] IMPLICIT InternationalString OPTIONAL, + userId [3] IMPLICIT InternationalString OPTIONAL, + retentionTime [4] IMPLICIT IntUnit OPTIONAL, + permissions [5] IMPLICIT Permissions OPTIONAL, + description [6] IMPLICIT InternationalString OPTIONAL, + targetReference [7] IMPLICIT OCTET STRING OPTIONAL, + creationDateTime [8] IMPLICIT GeneralizedTime OPTIONAL, + taskStatus [9] IMPLICIT INTEGER{ + pending (0), + active (1), + complete (2), + aborted (3)}, + packageDiagnostics [10] IMPLICIT SEQUENCE OF DiagRec OPTIONAL, + taskSpecificParameters [11] IMPLICIT EXTERNAL + -- Use oid for specific ES definition + -- (same oid as packageType above) + -- and select [2] "taskPackage." + } +END + +AccessControlFormat-Prompt-1 +{z39-50-accessControl prompt-1 (1)} DEFINITIONS ::= +BEGIN +IMPORTS InternationalString, DiagRec FROM Z39-50-APDU-1995; +-- +PromptObject ::= CHOICE{ + challenge [1] IMPLICIT Challenge, + response [2] IMPLICIT Response} + + Challenge ::= SEQUENCE OF SEQUENCE { + promptId [1] PromptId, + -- Target supplies a number (for an enumerated + -- prompt) or string (for a non-enumerated + -- prompt), for each prompt, and the origin + -- returns it in response, for this prompt, so + -- target may correlate the prompt response with + -- the prompt. + defaultResponse [2] IMPLICIT InternationalString OPTIONAL, + promptInfo [3] CHOICE{ + character [1] IMPLICIT InternationalString, + encrypted [2] IMPLICIT Encryption} OPTIONAL, + -- Information corresponding to an + -- emumerated prompt. For example if 'type', + -- within PromptId, is 'copyright', then + -- promptInfo may contain a copyright + -- statement. + regExpr [4] IMPLICIT InternationalString OPTIONAL, + -- A regular expression that promptResponse should + -- match. See IEEE 1003.2 Volume 1, Section 2.8 + -- "Regular Expression Notation." For example if + -- promptId is "Year of publication," regExpr + -- might be "19[89][0-9]|20[0-9][0-9]". + responseRequired [5] IMPLICIT NULL OPTIONAL, + allowedValues [6] IMPLICIT SEQUENCE OF InternationalString OPTIONAL, + -- e.g. promptId="Desired color"; allowed = 'red', + -- 'blue','Green'. + shouldSave [7] IMPLICIT NULL OPTIONAL, + -- Target recommends that origin save the data + -- that it prompts from the user corresponding to + -- this prompt, because it is likely to be + -- requested again (so origin might not have to + -- prompt the user next time). + dataType [8] IMPLICIT INTEGER{ + integer (1), + date (2), + float (3), + alphaNumeric (4), + url-urn (5), + boolean (6)} OPTIONAL, + -- Target telling origin type of data it + -- wants. E.g., if "date" is specified, + -- presumably the origin will try to prompt + -- something "date-like" from the user. + diagnostic [9] IMPLICIT EXTERNAL OPTIONAL + -- Intended for repeat requests when there is an + -- error the origin should report to the user from + -- previous attempt. + } + + + Response ::= SEQUENCE OF SEQUENCE { + promptId [1] PromptId, + -- Corresponds to a prompt in the challenge, or + -- may be unprompted, for example "newPassword." + -- If unprompted, should be "enumerated." + -- If this responds to a non-enumerated prompt, + -- then nonEnumeratedPrompt should contain the + -- prompt string from the challenge. + promptResponse [2] CHOICE{ + string [1] IMPLICIT InternationalString, + accept [2] IMPLICIT BOOLEAN, + acknowledge [3] IMPLICIT NULL, + diagnostic [4] DiagRec, + encrypted [5] IMPLICIT Encryption}} + + + PromptId ::= CHOICE{ + enummeratedPrompt [1] IMPLICIT SEQUENCE{ + type [1] IMPLICIT INTEGER{ + groupId (0), + userId (1), + password (2), + newPassword (3), + copyright (4), + -- When type on Challenge is + -- 'copyright', promptInfo has text of + -- copyright message to be displayed + -- verbatim to the user. If + -- promptResponse indicates + -- 'acceptance', this indicates the + -- user has been shown, and accepted, + -- the terms of the copyright. This is + -- not intended to be legally binding, + -- but provides a good-faith attempt + -- on the part of the target to inform + -- the user of the copyright. + sessionId (5)}, + suggestedString [2] IMPLICIT + InternationalString OPTIONAL}, + nonEnumeratedPrompt [2] IMPLICIT InternationalString} + + + Encryption ::= SEQUENCE{ + cryptType [1] IMPLICIT OCTET STRING OPTIONAL, + credential [2] IMPLICIT OCTET STRING OPTIONAL, + --random number, SALT, or other factor + data [3] IMPLICIT OCTET STRING} + +END + + + + + +AccessControlFormat-des-1 +{z39-50-accessControlFormat des-1 (2)} DEFINITIONS ::= +BEGIN + DES-RN-Object ::= CHOICE { + challenge [1] IMPLICIT DRNType, + response [2] IMPLICIT DRNType} + + DRNType ::= SEQUENCE{ + userId [1] IMPLICIT OCTET STRING OPTIONAL, + salt [2] IMPLICIT OCTET STRING OPTIONAL, + randomNumber [3] IMPLICIT OCTET STRING} +END + + + + + +AccessControlFormat-krb-1 +{z39-50-accessControlFormat krb-1 (3)} DEFINITIONS ::= +BEGIN +IMPORTS InternationalString FROM Z39-50-APDU-1995; + + KRBObject ::= CHOICE { + challenge [1] IMPLICIT KRBRequest, + response [2] IMPLICIT KRBResponse} + + KRBRequest ::= SEQUENCE{ + service [1] IMPLICIT InternationalString, + instance [2] IMPLICIT InternationalString OPTIONAL, + realm [3] IMPLICIT InternationalString OPTIONAL + -- target requests a ticket for the given service, + -- instance, and realm + } + + KRBResponse ::= SEQUENCE{ + userid [1] IMPLICIT InternationalString OPTIONAL, + ticket [2] IMPLICIT OCTET STRING + -- origin responds with a ticket for the requested + -- service + } +END + +UserInfoFormat-searchResult-1 +{z39-50-userInfoFormat searchResult-1 (1)} DEFINITIONS ::= +BEGIN +IMPORTS DatabaseName, Term, Query, IntUnit, InternationalString +FROM Z39-50-APDU-1995; + +SearchInfoReport ::= SEQUENCE OF SEQUENCE{ + subqueryId [1] IMPLICIT InternationalString OPTIONAL, + -- shorthand identifier of subquery + fullQuery [2] IMPLICIT BOOLEAN, + -- 'true' means this is the full query; + -- 'false', a sub-query + subqueryExpression [3] QueryExpression OPTIONAL, + + -- A subquery of the query as submitted. May + -- be whole query; if so, "fullQuery" should + -- be 'true'. + subqueryInterpretation [4] QueryExpression OPTIONAL, + + -- how target interpreted subquery + subqueryRecommendation [5] QueryExpression OPTIONAL, + -- target-recommended alternative + subqueryCount [6] IMPLICIT INTEGER OPTIONAL, + -- Number of records for this subQuery, + -- across all of the specified databases. + -- (If during search, via resource control, + -- number of records so far). + subqueryWeight [7] IMPLICIT IntUnit OPTIONAL, + -- relative weight of this subquery + resultsByDB [8] IMPLICIT ResultsByDB OPTIONAL} + +ResultsByDB ::= SEQUENCE OF SEQUENCE{ + databases [1] CHOICE{ + all [1] IMPLICIT NULL, + -- applies across all of the databases in + -- Search PDU + list [2] IMPLICIT SEQUENCE OF DatabaseName + -- applies across all databases in this + -- list + }, + count [2] IMPLICIT INTEGER OPTIONAL, + -- Number of records for query component (and, as + -- above, if during search, via resource control, + -- number of records so far). + resultSetName [3] IMPLICIT InternationalString OPTIONAL + -- Target-assigned result set by which subQuery is + -- available. Should not be provided unless + -- processing for this query component is concluded + -- (i.e., when this report comes during search, via + -- resource control, as opposed to after search, via + -- additionalSearchInfo). + } + +QueryExpression ::= CHOICE { + term [1] IMPLICIT SEQUENCE{ + queryTerm [1] Term, + termComment [2] IMPLICIT InternationalString OPTIONAL}, + query [2] Query} +END diff --git a/epan/dissectors/asn1/z3950/z3950-oclc.asn b/epan/dissectors/asn1/z3950/z3950-oclc.asn new file mode 100644 index 0000000000..e6592405c7 --- /dev/null +++ b/epan/dissectors/asn1/z3950/z3950-oclc.asn @@ -0,0 +1,14 @@ +Z39-50-OCLC-UserInformation +{z39-50-userInformation local (1000) oclc (17) oclc-1 (1)} DEFINITIONS ::= + +BEGIN +OCLC-UserInformation ::= SEQUENCE { + motd [1] IMPLICIT VisibleString OPTIONAL, + dblist SEQUENCE OF DBName OPTIONAL, + failReason [3] IMPLICIT BOOLEAN OPTIONAL, + text [2] IMPLICIT VisibleString OPTIONAL + } + +DBName ::= [2] IMPLICIT VisibleString +END + diff --git a/epan/dissectors/asn1/z3950/z3950.asn b/epan/dissectors/asn1/z3950/z3950.asn new file mode 100644 index 0000000000..e63f46d840 --- /dev/null +++ b/epan/dissectors/asn1/z3950/z3950.asn @@ -0,0 +1,807 @@ +ANSI-Z39-50-ObjectIdentifier DEFINITIONS ::= +BEGIN +z39-50 OBJECT IDENTIFIER ::= +{ iso (1) member-body (2) us (840) ansi-standard-Z39-50 (10003)} +-- thus {Z39-50} is shorthand for {1 2 840 10003} +Z39-50-APDU OBJECT IDENTIFIER ::= {Z39-50 2} -- See OID.3 +-- and {Z39-50 2} is shorthand for {1 2 840 10003 2} and so on. +Z39-50-attributeSet OBJECT IDENTIFIER ::= {Z39-50 3} -- See Appendix ATR +z39-50-diagnostic OBJECT IDENTIFIER ::= {z39-50 4} -- See Appendix DIAG +z39-50-recordSyntax OBJECT IDENTIFIER ::= {z39-50 5} --See Appendix REC +Z39-50-resourceReport OBJECT IDENTIFIER ::= {Z39-50 7} --See Appendix RSC +Z39-50-accessControl OBJECT IDENTIFIER ::= {Z39-50 8} --See Appendix ACC +Z39-50-extendedService OBJECT IDENTIFIER ::= {Z39-50 9} --See Appendix EXT +Z39-50-userInfoFormat OBJECT IDENTIFIER ::= {Z39-50 10} --See Appendix USR +Z39-50-elementSpec OBJECT IDENTIFIER ::= {Z39-50 11} --See Appendix ESP +Z39-50-variantSet OBJECT IDENTIFIER ::= {Z39-50 12} --See Appendix VAR +Z39-50-schema OBJECT IDENTIFIER ::= {Z39-50 13} --See Appendix TAG +Z39-50-tagSet OBJECT IDENTIFIER ::= {Z39-50 14} --See Appendix TAG +Z39-50-negotiation OBJECT IDENTIFIER ::= {Z39-50 15} +Z39-50-query OBJECT IDENTIFIER ::= {Z39-50 16} +END + +Z39-50-APDU-1995 + -- OID for this definition, assigned in OID.3.1, is {Z39-50 2 1} + +DEFINITIONS ::= +BEGIN -- Z39.50-1995 Maintenance Agency Official Text for ANSI/NISO Z39.50-1995 - July 1995 +-- +EXPORTS OtherInformation, Term, +AttributeSetId, AttributeList, +AttributeElement, ElementSetName, SortElement, DatabaseName, CompSpec, +Specification, Permissions, InternationalString, IntUnit, Unit, +StringOrNumeric, Query, Records, ResultSetId, DefaultDiagFormat, DiagRec; +-- +PDU ::= CHOICE{ + initRequest [20] IMPLICIT InitializeRequest, + initResponse [21] IMPLICIT InitializeResponse, + searchRequest [22] IMPLICIT SearchRequest, + searchResponse [23] IMPLICIT SearchResponse, + presentRequest [24] IMPLICIT PresentRequest, + presentResponse [25] IMPLICIT PresentResponse, + deleteResultSetRequest [26] IMPLICIT DeleteResultSetRequest, + deleteResultSetResponse [27] IMPLICIT DeleteResultSetResponse, + accessControlRequest [28] IMPLICIT AccessControlRequest, + accessControlResponse [29] IMPLICIT AccessControlResponse, + resourceControlRequest [30] IMPLICIT ResourceControlRequest, + resourceControlResponse [31] IMPLICIT ResourceControlResponse, + triggerResourceControlRequest [32] IMPLICIT TriggerResourceControlRequest, + resourceReportRequest [33] IMPLICIT ResourceReportRequest, + resourceReportResponse [34] IMPLICIT ResourceReportResponse, + scanRequest [35] IMPLICIT ScanRequest, + scanResponse [36] IMPLICIT ScanResponse, + -- [37] through [42] reserved + sortRequest [43] IMPLICIT SortRequest, + sortResponse [44] IMPLICIT SortResponse, + segmentRequest [45] IMPLICIT Segment, + extendedServicesRequest [46] IMPLICIT ExtendedServicesRequest, + extendedServicesResponse [47] IMPLICIT ExtendedServicesResponse, + close [48] IMPLICIT Close} + +-- Initialize APDUs +-- + + InitializeRequest ::= SEQUENCE{ + referenceId ReferenceId OPTIONAL, + protocolVersion ProtocolVersion, + options Options, + preferredMessageSize [5] IMPLICIT INTEGER, + exceptionalRecordSize [6] IMPLICIT INTEGER, +-- idAuthentication [7] ANY OPTIONAL, see note below + idAuthentication [7] CHOICE{ + open VisibleString, + idPass SEQUENCE { + groupId [0] IMPLICIT InternationalString OPTIONAL, + userId [1] IMPLICIT InternationalString OPTIONAL, + password [2] IMPLICIT InternationalString OPTIONAL }, + anonymous NULL, + other EXTERNAL} OPTIONAL, + implementationId [110] IMPLICIT InternationalString OPTIONAL, + implementationName [111] IMPLICIT InternationalString OPTIONAL, + implementationVersion [112] IMPLICIT InternationalString OPTIONAL, + userInformationField [11] EXTERNAL OPTIONAL, + otherInfo OtherInformation OPTIONAL} +--Note: +-- For idAuthentication, the type ANY is retained +-- for compatibility with earlier versions. +-- For interoperability, the following is recommended: +-- IdAuthentication [7] CHOICE{ +-- open VisibleString, +-- idPass SEQUENCE { +-- groupId [0] IMPLICIT InternationalString OPTIONAL, +-- userId [1] IMPLICIT InternationalString OPTIONAL, +-- password [2] IMPLICIT InternationalString OPTIONAL }, +-- anonymous NULL, +-- other EXTERNAL +-- May use access control formats for 'other'. See Appendix 7 ACC. +-- + InitializeResponse ::= SEQUENCE{ + referenceId ReferenceId OPTIONAL, + protocolVersion ProtocolVersion, + options Options, + preferredMessageSize [5] IMPLICIT INTEGER, + exceptionalRecordSize [6] IMPLICIT INTEGER, + result [12] IMPLICIT BOOLEAN, + -- relect = FALSE; Accept = TRUE + implementationId [110] IMPLICIT InternationalString OPTIONAL, + implementationName [111] IMPLICIT InternationalString OPTIONAL, + implementationVersion [112] IMPLICIT InternationalString OPTIONAL, + userInformationField [11] EXTERNAL OPTIONAL, + otherInfo OtherInformation OPTIONAL} +-- Begin auxiliary definitions for Init PDUs + ProtocolVersion ::= [3] IMPLICIT BIT STRING{ + version-1 (0), + -- This bit should always be set, but does not + -- correspond to any Z39.50 version. + version-2 (1), + -- "Version 2 supported." + -- This bit should always be set. + version-3 (2) + -- "Version 3 supported." +-- Values higher than 'version-3' should be ignored. Both the Initialize +-- request and Initialize Response APDUs include a value string corresponding +-- to the supported versions. The highest common version is selected +-- for use. If there are no versions in common, "Result" in the Init Response +-- should indicate "reject." +-- Note: Versions 1 and 2 are identical. Systems supporting version 2 should +-- indicate support for version 1 as well, for interoperability with systems +-- that indicate support for version 1 only (e.g. ISO 10163-1991 +-- implementations). + } + Options ::= [4] IMPLICIT BIT STRING{ + search (0), + present (1), + delSet (2), + resourceReport (3), + triggerResourceCtrl (4), + resourceCtrl (5), + accessCtrl (6), + scan (7), + sort (8), + -- (9) (reserved) + extendedServices (10), + level-1Segmentation (11), + level-2Segmentation (12), + concurrentOperations (13), + namedResultSets (14)} +-- end auxiliary definitions for Init PDUs + + +--Search APDUs + SearchRequest ::= SEQUENCE{ + referenceId ReferenceId OPTIONAL, + smallSetUpperBound [13] IMPLICIT INTEGER, + largeSetLowerBound [14] IMPLICIT INTEGER, + mediumSetPresentNumber [15] IMPLICIT INTEGER, + replaceIndicator [16] IMPLICIT BOOLEAN, + resultSetName [17] IMPLICIT InternationalString, + databaseNames [18] IMPLICIT SEQUENCE OF DatabaseName, + smallSetElementSetNames [100] ElementSetNames OPTIONAL, + mediumSetElementSetNames [101] ElementSetNames OPTIONAL, + preferredRecordSyntax [104] IMPLICIT OBJECT IDENTIFIER OPTIONAL, + query [21] Query, + -- Following two parameters may be used only if version 3 is in force. + additionalSearchInfo [203] IMPLICIT OtherInformation OPTIONAL, + otherInfo OtherInformation OPTIONAL} + + +-- Query Definitions + Query ::= CHOICE{ + type-0 [0] ANY, + type-1 [1] IMPLICIT RPNQuery, + type-2 [2] OCTET STRING, + type-100 [100] OCTET STRING, + type-101 [101] IMPLICIT RPNQuery, + type-102 [102] OCTET STRING} +-- +-- Definitions for RPN query + RPNQuery ::= SEQUENCE{ + attributeSet AttributeSetId, + rpn RPNStructure} +-- + RPNStructure ::= CHOICE{ + op [0] Operand, + rpnRpnOp [1] IMPLICIT SEQUENCE{ + rpn1 RPNStructure, + rpn2 RPNStructure, + op Operator }} + Operand ::= CHOICE{ + attrTerm AttributesPlusTerm, + resultSet ResultSetId, + -- If version 2 is in force: + -- - If query type is 1, one of the above two must be chosen; + -- - resultAttr (below) may be used only if query type is 101. + resultAttr ResultSetPlusAttributes} + + AttributesPlusTerm ::= [102] IMPLICIT SEQUENCE{ + attributes AttributeList, + term Term} + + ResultSetPlusAttributes ::= [214] IMPLICIT +SEQUENCE{ + resultSet ResultSetId, + attributes AttributeList} + + AttributeList ::= [44] IMPLICIT SEQUENCE OF AttributeElement +-- + Term ::= CHOICE{ + general [45] IMPLICIT OCTET STRING, + -- values below may be used only if version 3 is in force + numeric [215] IMPLICIT INTEGER, + characterString [216] IMPLICIT InternationalString, + oid [217] IMPLICIT OBJECT IDENTIFIER, + dateTime [218] IMPLICIT GeneralizedTime, + external [219] IMPLICIT EXTERNAL, + integerAndUnit [220] IMPLICIT IntUnit, + null [221] IMPLICIT NULL} + + Operator ::= [46] CHOICE{ + and [0] IMPLICIT NULL, + or [1] IMPLICIT NULL, + and-not [2] IMPLICIT NULL, + -- If version 2 is in force: + -- - For query type 1, one of the above three + -- must be chosen; + -- - prox (below) may be used only if query type + -- is 101. + prox [3] IMPLICIT ProximityOperator} + + AttributeElement ::= SEQUENCE{ + attributeSet [1] IMPLICIT AttributeSetId OPTIONAL, + -- Must be omitted if version 2 is in force. + -- If included, overrides value of attributeSet + -- in RPNQuery above, but only for this attribute. + attributeType [120] IMPLICIT INTEGER, + attributeValue CHOICE{ + numeric [121] IMPLICIT INTEGER, + -- If version 2 is in force, + -- Must select 'numeric' for attributeValue. + + complex [224] IMPLICIT SEQUENCE{ + list [1] IMPLICIT SEQUENCE OF StringOrNumeric, + semanticAction [2] IMPLICIT SEQUENCE OF INTEGER OPTIONAL}}} + + + ProximityOperator ::= SEQUENCE{ + exclusion [1] IMPLICIT BOOLEAN OPTIONAL, + distance [2] IMPLICIT INTEGER, + ordered [3] IMPLICIT BOOLEAN, + relationType [4] IMPLICIT INTEGER{ + lessThan (1), + lessThanOrEqual (2), + equal (3), + greaterThanOrEqual (4), + greaterThan (5), + notEqual (6)}, + proximityUnitCode [5] CHOICE{ + known [1] IMPLICIT KnownProximityUnit, + private [2] IMPLICIT INTEGER}} +-- + KnownProximityUnit ::= INTEGER{ + character (1), + word (2), + sentence (3), + paragraph (4), + section (5), + chapter (6), + document (7), + element (8), + subelement (9), + elementType (10), + byte (11) -- Version 3 only + } +-- End definitions for RPN Query + + +SearchResponse ::= SEQUENCE{ + referenceId ReferenceId OPTIONAL, + resultCount [23] IMPLICIT INTEGER, + numberOfRecordsReturned [24] IMPLICIT INTEGER, + nextResultSetPosition [25] IMPLICIT INTEGER, + searchStatus [22] IMPLICIT BOOLEAN, + resultSetStatus [26] IMPLICIT INTEGER{ + subset (1), + interim (2), + none (3)} OPTIONAL, + presentStatus PresentStatus OPTIONAL, + records Records OPTIONAL, + -- Following two parameters may be used only if version 3 is in force. + additionalSearchInfo [203] IMPLICIT OtherInformation OPTIONAL, + otherInfo OtherInformation OPTIONAL} + + + +--Retrieval APDUs + PresentRequest ::= SEQUENCE{ + referenceId ReferenceId OPTIONAL, + resultSetId ResultSetId, + resultSetStartPoint [30] IMPLICIT INTEGER, + numberOfRecordsRequested [29] IMPLICIT INTEGER, + additionalRanges [212] IMPLICIT SEQUENCE OF Range OPTIONAL, + -- additionalRanges may be included only if version 3 is in force. + recordComposition CHOICE{ + simple [19] ElementSetNames, + -- must choose 'simple' if version 2 + -- is in force + complex [209] IMPLICIT CompSpec} +OPTIONAL, + preferredRecordSyntax [104] IMPLICIT OBJECT IDENTIFIER OPTIONAL, + maxSegmentCount [204] IMPLICIT INTEGER OPTIONAL, -- level 1 or 2 + maxRecordSize [206] IMPLICIT INTEGER OPTIONAL, -- level 2 only + maxSegmentSize [207] IMPLICIT INTEGER OPTIONAL, -- level 2 only + otherInfo OtherInformation OPTIONAL} +-- + + Segment ::= SEQUENCE{ + -- Segment PDU may only be used when version 3 is in force, + -- and only when segmentation is in effect. + referenceId ReferenceId OPTIONAL, + numberOfRecordsReturned [24] IMPLICIT INTEGER, + segmentRecords [0] IMPLICIT SEQUENCE OF NamePlusRecord, + otherInfo OtherInformation OPTIONAL} +-- + PresentResponse ::= SEQUENCE{ + referenceId ReferenceId OPTIONAL, + numberOfRecordsReturned [24] IMPLICIT INTEGER, + nextResultSetPosition [25] IMPLICIT INTEGER, + presentStatus PresentStatus, + records Records OPTIONAL, + otherInfo OtherInformation OPTIONAL} +-- begin auxiliary definitions for Search and Present APDUs + +-- begin definition of records + Records ::= CHOICE{ + responseRecords [28] IMPLICIT SEQUENCE OF NamePlusRecord, + nonSurrogateDiagnostic [130] IMPLICIT DefaultDiagFormat, + multipleNonSurDiagnostics [205] IMPLICIT SEQUENCE OF DiagRec} +-- + NamePlusRecord ::= SEQUENCE{ + name [0] IMPLICIT DatabaseName OPTIONAL, + record [1] CHOICE{ + retrievalRecord [1] EXTERNAL, + surrogateDiagnostic [2] DiagRec, + -- Must select one of the above two, retrievalRecord or + -- surrogateDiagnostic, unless 'level 2 segmentation' + -- is in effect. + startingFragment [3] FragmentSyntax, + intermediateFragment [4] FragmentSyntax, + finalFragment [5] FragmentSyntax}} + + FragmentSyntax ::= CHOICE{ + externallyTagged EXTERNAL, + notExternallyTagged OCTET STRING} + + DiagRec ::= CHOICE{ + defaultFormat DefaultDiagFormat, + -- Must choose defaultFormat if version 2 is in effect. + externallyDefined EXTERNAL} + + DefaultDiagFormat::= SEQUENCE{ + diagnosticSetId OBJECT IDENTIFIER, + condition INTEGER, + addinfo CHOICE{ + v2Addinfo VisibleString, -- version 2 + v3Addinfo InternationalString -- version 3 + }} + -- end definition of records + + Range ::= SEQUENCE{ + startingPosition [1] IMPLICIT INTEGER, + numberOfRecords [2] IMPLICIT INTEGER} +-- + ElementSetNames ::= CHOICE { + genericElementSetName [0] IMPLICIT InternationalString, + databaseSpecific [1] IMPLICIT SEQUENCE OF SEQUENCE{ + dbName DatabaseName, + esn ElementSetName}} + + + PresentStatus ::= [27] IMPLICIT INTEGER{ + success (0), + partial-1 (1), + partial-2 (2), + partial-3 (3), + partial-4 (4), + failure (5)} + +-- begin definition of composition specification + CompSpec ::= SEQUENCE{ + selectAlternativeSyntax [1] IMPLICIT BOOLEAN, + -- See comment for recordSyntax, below. + generic [2] IMPLICIT Specification OPTIONAL, + dbSpecific [3] IMPLICIT SEQUENCE OF SEQUENCE{ + db [1] DatabaseName, + spec [2] IMPLICIT Specification} OPTIONAL, + -- At least one of generic and dbSpecific must + -- occur, and both may occur. If both, then for + -- any record not in the list of databases + -- within dbSpecific, generic applies. + recordSyntax [4] IMPLICIT SEQUENCE OF OBJECT IDENTIFIER OPTIONAL + -- For each record, the target selects the + -- first record syntax in this list that it can + -- support. If the list is exhausted, the + -- target may select an alternative syntax if + -- selectAlternativeSyntax is 'true'. + } + + Specification ::= SEQUENCE{ + schema [1] IMPLICIT OBJECT IDENTIFIER OPTIONAL, + elementSpec [2] CHOICE{ + elementSetName [1] IMPLICIT InternationalString, + externalEspec [2] IMPLICIT EXTERNAL} OPTIONAL} +-- end definition of composition specification +-- end auxiliary definitions for search and response APDUs + +-- Delete APDUs + DeleteResultSetRequest ::= SEQUENCE{ + referenceId ReferenceId OPTIONAL, + deleteFunction [32] IMPLICIT INTEGER{ + list (0), + all (1)}, + resultSetList SEQUENCE OF ResultSetId OPTIONAL, + otherInfo OtherInformation OPTIONAL} +-- + DeleteResultSetResponse ::= SEQUENCE{ + referenceId ReferenceId OPTIONAL, + deleteOperationStatus [0] IMPLICIT DeleteSetStatus, + deleteListStatuses [1] IMPLICIT ListStatuses OPTIONAL, + numberNotDeleted [34] IMPLICIT INTEGER OPTIONAL, + bulkStatuses [35] IMPLICIT ListStatuses OPTIONAL, + deleteMessage [36] IMPLICIT InternationalString OPTIONAL, + otherInfo OtherInformation OPTIONAL} + + ListStatuses ::= SEQUENCE OF SEQUENCE{ + id ResultSetId, + status DeleteSetStatus} + + DeleteSetStatus ::= [33] IMPLICIT INTEGER{ + success (0), + resultSetDidNotExist (1), + previouslyDeletedByTarget (2), + systemProblemAtTarget (3), + accessNotAllowed (4), + resourceControlAtOrigin (5), + resourceControlAtTarget (6), + bulkDeleteNotSupported (7), + notAllRsltSetsDeletedOnBulkDlte (8), + notAllRequestedResultSetsDeleted (9), + resultSetInUse (10)} +-- + +--Access- and Resource-control APDUs +-- + AccessControlRequest ::= SEQUENCE{ + referenceId ReferenceId OPTIONAL, + securityChallenge CHOICE{ + simpleForm [37] IMPLICIT OCTET STRING, + externallyDefined [0] EXTERNAL}, + otherInfo OtherInformation OPTIONAL} + + AccessControlResponse ::= SEQUENCE{ + referenceId ReferenceId OPTIONAL, + securityChallengeResponse CHOICE{ + simpleForm [38] IMPLICIT + OCTET STRING, + externallyDefined [0] EXTERNAL} + OPTIONAL, + -- Optional only in version 3; mandatory in + -- version 2. If omitted (in version 3) then + -- diagnostic must occur. + diagnostic [223] DiagRec OPTIONAL, -- Version 3 only. + otherInfo OtherInformation OPTIONAL} + + + + ResourceControlRequest ::= SEQUENCE{ + referenceId ReferenceId OPTIONAL, + suspendedFlag [39] IMPLICIT BOOLEAN OPTIONAL, + resourceReport [40] ResourceReport OPTIONAL, + partialResultsAvailable [41] IMPLICIT INTEGER{ + subset (1), + interim (2), + none (3)} OPTIONAL, + responseRequired [42] IMPLICIT BOOLEAN, + triggeredRequestFlag [43] IMPLICIT BOOLEAN OPTIONAL, + otherInfo OtherInformation OPTIONAL} + + + ResourceControlResponse ::= SEQUENCE{ + referenceId ReferenceId OPTIONAL, + continueFlag [44] IMPLICIT BOOLEAN, + resultSetWanted [45] IMPLICIT BOOLEAN OPTIONAL, + otherInfo OtherInformation OPTIONAL} + + + + TriggerResourceControlRequest ::= +SEQUENCE{ + referenceId ReferenceId OPTIONAL, + requestedAction [46] IMPLICIT INTEGER{ + resourceReport (1), + resourceControl (2), + cancel (3)}, + prefResourceReportFormat [47] IMPLICIT ResourceReportId OPTIONAL, + resultSetWanted [48] IMPLICIT BOOLEAN OPTIONAL, + otherInfo OtherInformation OPTIONAL} + + + + ResourceReportRequest ::= SEQUENCE{ + referenceId ReferenceId OPTIONAL, + opId [210] IMPLICIT ReferenceId OPTIONAL, + prefResourceReportFormat [49] IMPLICIT ResourceReportId OPTIONAL, + otherInfo OtherInformation OPTIONAL} +-- + ResourceReportResponse ::= SEQUENCE{ + referenceId ReferenceId OPTIONAL, + resourceReportStatus [50] IMPLICIT INTEGER{ + success (0), + partial (1), + failure-1 (2), + failure-2 (3), + failure-3 (4), + failure-4 (5), + failure-5 (6), + failure-6 (7)}, + resourceReport [51] ResourceReport OPTIONAL, + otherInfo OtherInformation OPTIONAL} +-- + ResourceReport ::= EXTERNAL + ResourceReportId ::= OBJECT IDENTIFIER + +--Scan APDUs + ScanRequest ::= SEQUENCE{ + referenceId ReferenceId OPTIONAL, + databaseNames [3] IMPLICIT SEQUENCE OF DatabaseName, + attributeSet AttributeSetId OPTIONAL, + termListAndStartPoint AttributesPlusTerm, + stepSize [5] IMPLICIT INTEGER OPTIONAL, + numberOfTermsRequested [6] IMPLICIT INTEGER, + preferredPositionInResponse [7] IMPLICIT INTEGER OPTIONAL, + otherInfo OtherInformation OPTIONAL} + + ScanResponse ::= SEQUENCE{ + referenceId ReferenceId OPTIONAL, + stepSize [3] IMPLICIT INTEGER OPTIONAL, + scanStatus [4] IMPLICIT INTEGER { + success (0), + partial-1 (1), + partial-2 (2), + partial-3 (3), + partial-4 (4), + partial-5 (5), + failure (6) }, + numberOfEntriesReturned [5] IMPLICIT INTEGER, + positionOfTerm [6] IMPLICIT INTEGER OPTIONAL, + entries [7] IMPLICIT ListEntries OPTIONAL, + attributeSet [8] IMPLICIT AttributeSetId OPTIONAL, + otherInfo OtherInformation OPTIONAL} + + +-- begin auxiliary definitions for Scan + ListEntries ::= SEQUENCE{ + entries [1] IMPLICIT SEQUENCE OF Entry OPTIONAL, + nonsurrogateDiagnostics [2] IMPLICIT SEQUENCE OF DiagRec OPTIONAL + -- At least one of entries and nonsurrogateDiagnostic must occur + } + + Entry ::= CHOICE { + termInfo [1] IMPLICIT TermInfo, + surrogateDiagnostic [2] DiagRec} +-- + TermInfo ::= SEQUENCE { + term Term, + displayTerm [0] IMPLICIT InternationalString OPTIONAL, + -- Presence of displayTerm means that term is + -- not considered by the target to be suitable + -- for display, and displayTerm should instead + -- be displayed. 'term' is the actual term in + -- the term list; 'displayTerm' is for display + -- purposes only, and is not an actual term in + -- the term list. + suggestedAttributes AttributeList OPTIONAL, + alternativeTerm [4] IMPLICIT SEQUENCE OF AttributesPlusTerm OPTIONAL, + globalOccurrences [2] IMPLICIT INTEGER OPTIONAL, + byAttributes [3] IMPLICIT OccurrenceByAttributes OPTIONAL, + otherTermInfo OtherInformation OPTIONAL} + + OccurrenceByAttributes ::= SEQUENCE OF +SEQUENCE{ + attributes [1] AttributeList, + occurrences CHOICE{ + global [2] INTEGER, + byDatabase [3] IMPLICIT SEQUENCE OF + SEQUENCE{ + db DatabaseName, + num [1] IMPLICIT INTEGER OPTIONAL, + otherDbInfo OtherInformation OPTIONAL}} + OPTIONAL, + otherOccurInfo OtherInformation OPTIONAL} +-- end auxiliary definitions for Scan + +-- Sort APDUs +SortRequest ::= SEQUENCE{ + referenceId ReferenceId OPTIONAL, + inputResultSetNames [3] IMPLICIT SEQUENCE OF InternationalString, + sortedResultSetName [4] IMPLICIT InternationalString, + sortSequence [5] IMPLICIT SEQUENCE OF SortKeySpec, + -- order of occurrence is + -- from major to minor + otherInfo OtherInformation OPTIONAL} + +SortResponse ::= SEQUENCE{ + referenceId ReferenceId OPTIONAL, + sortStatus [3] IMPLICIT INTEGER{ + success (0), + partial-1 (1), + failure (2)}, + resultSetStatus [4] IMPLICIT INTEGER{ + empty (1), + interim (2), + unchanged (3), + none (4)} OPTIONAL, + diagnostics [5] IMPLICIT SEQUENCE OF DiagRec OPTIONAL, + otherInfo OtherInformation OPTIONAL} + +-- begin auxiliary definitions for Sort + SortKeySpec ::= SEQUENCE{ + sortElement SortElement, + sortRelation [1] IMPLICIT INTEGER{ + ascending (0), + descending (1), + ascendingByFrequency (3), + descendingByfrequency (4)}, + caseSensitivity [2] IMPLICIT INTEGER{ + caseSensitive (0), + caseInsensitive (1)}, + missingValueAction [3] CHOICE{ + abort [1] IMPLICIT NULL, + null [2] IMPLICIT NULL, + -- supply a null value + -- for missing value + missingValueData [3] IMPLICIT OCTET + STRING} OPTIONAL} + + SortElement ::= CHOICE{ + generic [1] SortKey, + datbaseSpecific [2] IMPLICIT SEQUENCE OF SEQUENCE{ + databaseName DatabaseName, + dbSort SortKey}} + + SortKey ::= CHOICE{ + sortfield [0] IMPLICIT InternationalString, + -- An element, element-group-tag, or alias + -- supported by the target and denoting a set + -- of elements associated with each record. + elementSpec [1] IMPLICIT Specification, + sortAttributes [2] IMPLICIT SEQUENCE{ + id AttributeSetId, + list AttributeList}} +-- end auxiliary definitions for sort + + + +-- Extended Service APDUs + ExtendedServicesRequest ::= SEQUENCE{ + referenceId ReferenceId OPTIONAL, + function [3] IMPLICIT INTEGER { + create (1), + delete (2), + modify (3)}, + packageType [4] IMPLICIT OBJECT IDENTIFIER, + packageName [5] IMPLICIT InternationalString OPTIONAL, + -- PackageName mandatory for 'modify' or + -- 'delete'; optional for 'create'. + -- Following four parameters mandatory + -- for 'create'; should be included on + -- 'modify' if being modified; not needed + -- on 'delete'. + userId [6] IMPLICIT InternationalString OPTIONAL, + retentionTime [7] IMPLICIT IntUnit OPTIONAL, + permissions [8] IMPLICIT Permissions OPTIONAL, + description [9] IMPLICIT InternationalString OPTIONAL, + taskSpecificParameters [10] IMPLICIT EXTERNAL OPTIONAL, + -- Mandatory for 'create'; included on + -- 'modify' if specific parameters being + -- modified; not necessary on 'delete'. + -- For the 'EXTERNAL,' use OID of + -- specific ES definition and select + -- CHOICE [1]: 'esRequest'. + waitAction [11] IMPLICIT INTEGER{ + wait (1), + waitIfPossible (2), + dontWait (3), + dontReturnPackage (4)}, + elements ElementSetName OPTIONAL, + otherInfo OtherInformation OPTIONAL} +-- + +ExtendedServicesResponse ::= SEQUENCE{ + referenceId ReferenceId OPTIONAL, + operationStatus [3] IMPLICIT INTEGER{ + done (1), + accepted (2), + failure (3)}, + diagnostics [4] IMPLICIT SEQUENCE OF DiagRec OPTIONAL, + taskPackage [5] IMPLICIT EXTERNAL OPTIONAL, + -- Use OID: {Z39-50-recordSyntax (106)} + -- and corresponding syntax. For the + -- EXTERNAL, 'taskSpecific,' within that + -- definition, use OID of the specific + -- es, and choose [2], 'taskPackage'. + otherInfo OtherInformation OPTIONAL} + + Permissions ::= SEQUENCE OF SEQUENCE{ + userId [1] IMPLICIT InternationalString, + allowableFunctions [2] IMPLICIT SEQUENCE OF INTEGER{ + delete (1), + modifyContents (2), + modifyPermissions (3), + present (4), + invoke (5)}} + +Close ::= SEQUENCE{ + referenceId ReferenceId OPTIONAL, -- See 3.2.11.1.5. + closeReason CloseReason, + diagnosticInformation [3] IMPLICIT InternationalString OPTIONAL, + resourceReportFormat [4] IMPLICIT ResourceReportId OPTIONAL, + -- For use by origin only, and only on + -- Close request; origin requests target + -- to include report in response. + resourceReport [5] ResourceReport OPTIONAL, + -- For use by target only, unilaterally + -- on Close request; on Close response + -- may be unilateral or in response to + -- origin request. + otherInfo OtherInformation OPTIONAL} + + CloseReason ::= [211] IMPLICIT INTEGER{ + finished (0), + shutdown (1), + systemProblem (2), + costLimit (3), + resources (4), + securityViolation (5), + protocolError (6), + lackOfActivity (7), + peerAbort (8), + unspecified (9)} + + +-- Global auxiliary definitions + ReferenceId ::= [2] IMPLICIT OCTET STRING + ResultSetId ::= [31] IMPLICIT InternationalString + ElementSetName ::= [103] IMPLICIT InternationalString + DatabaseName ::= [105] IMPLICIT InternationalString + AttributeSetId ::= OBJECT IDENTIFIER + + +-- OtherInformation + OtherInformation ::= [201] IMPLICIT SEQUENCE OF +SEQUENCE{ + category [1] IMPLICIT InfoCategory OPTIONAL, + information CHOICE{ + characterInfo [2] IMPLICIT InternationalString, + binaryInfo [3] IMPLICIT OCTET STRING, + externallyDefinedInfo [4] IMPLICIT EXTERNAL, + oid [5] IMPLICIT OBJECT IDENTIFIER}} +-- + InfoCategory ::= SEQUENCE{ + categoryTypeId [1] IMPLICIT OBJECT IDENTIFIER OPTIONAL, + categoryValue [2] IMPLICIT INTEGER} + + +-- Units + -- IntUnit is used when value and unit are supplied together. Unit, alone, + -- is used when just specifying a unit (without a value). For example, + -- IntUnit is used in Term, in an RPNQuery, or it can be the datatype of + -- an element within a retrieval record. Unit (alone) would be used in an + -- element request, when requesting data be returned according to a + -- particular unit. + + IntUnit ::= SEQUENCE{ + value [1] IMPLICIT INTEGER, + unitUsed [2] IMPLICIT Unit} +-- + Unit ::= SEQUENCE{ + unitSystem [1] InternationalString OPTIONAL, -- e.g. 'SI' + unitType [2] StringOrNumeric OPTIONAL, -- e.g. 'mass' + unit [3] StringOrNumeric OPTIONAL, -- e.g. 'kilograms' + scaleFactor [4] IMPLICIT INTEGER OPTIONAL -- e.g. 9 means 10**9 + } + +--CharacterString + InternationalString ::= GeneralString + -- When version 2 is in force, this collapses to VisibleString. That + -- is, only characters in the visibleString repertoire may be used. + -- (Datatype compatibility with version 2 is not affected, because + -- references are IMPLICIT.) When version 3 is in force, the semantics + -- of the GeneralString content may be altered by negotiation during + -- initialization. If no such negotiation is in effect, then + -- GeneralString semantics are in force. + +StringOrNumeric ::= CHOICE{ + string [1] IMPLICIT InternationalString, + numeric [2] IMPLICIT INTEGER} + +END --IR DEFINITIONS diff --git a/epan/dissectors/asn1/z3950/z3950.cnf b/epan/dissectors/asn1/z3950/z3950.cnf new file mode 100644 index 0000000000..94fa9b5eb4 --- /dev/null +++ b/epan/dissectors/asn1/z3950/z3950.cnf @@ -0,0 +1,278 @@ +# z3950.cnf +# Conformation file for the NISO Z39.50 Information Retrieval protocol +# Copyright 2018 Craig Jackson <cejackson51@gmail.com> + +# $Id$ + +#.MODULE_IMPORT + +#.EXPORTS + +#.PDU +#Z39-50-APDU-1995 + +#.NO_EMIT + +#.TYPE_RENAME + +#.FIELD_RENAME +AttributeList/_untag/_item attributeList_item +OtherInformation/_untag/_item otherInformation_item +RPNStructure/rpnRpnOp/op operatorRpnOp +RPNStructure/op operandRpnOp +SearchResponse/resultSetStatus search_resultSetStatus +SortResponse/resultSetStatus sort_resultSetStatus +AttributeElement/attributeValue/numeric attributeValue_numeric +AttributeElement/attributeValue/complex attributeValue_complex +AttributeElement/attributeValue/complex/list attributeValue_complex_list +AttributeElement/attributeType attributeElement_attributeType +ListStatuses/_item/id listStatuses_id +CompSpec/generic compSpec_generic +SortElement/generic sortElement_generic +ScanResponse/entries scanResponse_entries +ListEntries/entries listEntries_entries +Specification/elementSpec specification_elementSpec +SortKey/elementSpec sortKey_elementSpec +SortKey/sortAttributes/list sortAttributes_list +SortKey/sortAttributes/id sortAttributes_id +PresentRequest/recordComposition/complex recordComposition_complex +DiagFormat/recordSyntax diagFormat_recordSyntax +DiagFormat/sort/dbSpecific diagFormat_sort_dbSpecific +DiagFormat/sort/tooMany diagFormat_sort_tooMany +DiagnosticFormat/_item/diagnostic diagnosticFormat_item_diagnostic +DiagFormat/proximity diagFormat_proximity +DiagFormat/proximity/exclusion diagFormat_proximity_exclusion +DiagFormat/proximity/ordered diagFormat_proximity_ordered +DiagFormat/proximity/unit diagFormat_proximity_unit +DiagFormat/accessCtrl/oid diagFormat_accessCtrl_oid +DiagFormat/accessCtrl/simple diagFormat_accessCtrl_simple +DiagFormat/term diagFormat_term +SortKeyDetails/caseSensitivity sortKeyDetails_caseSensitivity +SortKeyDetails/sortType/structured sortKeyDetails_sortType_structured +SortKeyDetails/sortType/numeric sortKeyDetails_sortType_numeric +PrivateCapabilities/operators privateCapabilities_operators +PromptId/enummeratedPrompt/type promptId_enummeratedPrompt_type +ExtendedServicesInfo/waitAction extendedServicesInfo_waitAction +NetworkAddress/other networkAddress_other +NetworkAddress/other/address networkAddress_other_address +NetworkAddress/other/type networkAddress_other_type +AttributeDescription/attributeValue attributeDescription_attributeValue +AttributeTypeDetails/attributeValues attributeTypeDetails_attributeValues +AttributeTypeDetails/attributeValues/_item attributeTypeDetails_attributeValues_item +AttributeOccurrence/attributeValues attributeOccurrence_attributeValues +AttributeValue/value attributeValue_value +DRNType/userId dRNType_userId +DES-RN-Object/challenge dES_RN_Object_challenge +DES-RN-Object/response rES_RN_Object_response +VariantSetInfo/variants variantSetInfo_variants +Variant/triples/_item/value variant_triples_item_value +Variant/triples/_item/value/unit variant_triples_item_value_unit +UnitType/units unitType_units +UnitInfo/units unitInfo_units +ValueDescription/unit valueDescription_unit +ProximitySupport/unitsSupported/_item/private/unit proximitySupport_unitsSupported_item_private_unit +ProximitySupport/unitsSupported/_item/private proximitySupport_unitsSupported_item_private +ProximitySupport/unitsSupported/_item/known proximitySupport_unitsSupported_item_known +Usage/type usage_type +FormatSpec/type formatSpec_type +ExtendedServicesInfo/type extendedServicesInfo_type +QueryExpression/term queryExpression_term +QueryTypeDetails/rpn queryTypeDetails_rpn +QueryTypeDetails/private queryTypeDetails_private +BriefBib/title briefBib_title +Charge/text charge_text +OCLC-UserInformation/text oCLC-UserInformation_text +CircRecord/restrictions circRecord_restrictions +ResourceControlRequest/responseRequired resourceControlRequest_responseRequired +KRBObject/challenge kRBObject_challenge +KRBObject/response kRBObject_response +CompSpec/recordSyntax compSpec_recordSyntax +DatabaseInfo/name databaseInfo_name +DatabaseInfo/nicknames databaseInfo_nicknames +DatabaseInfo/nicknames/_item databaseInfo_nicknames_item +NamePlusRecord/name namePlusRecord_name +BriefBib/format briefBib_format +TagSetInfo/elements tagSetInfo_elements +ElementSetDetails/elementSetName elementSetDetails_elementSetName +PrivateCapabilities/description privateCapabilities_description +TaskPackage/description taskPackage_description +ElementData/diagnostic elementData_diagnostic +Challenge/_item/diagnostic challenge_item_diagnostic +Challenge/_item/dataType challenge_item_dataType +Challenge/_item/promptInfo/character challenge_item_promptInfo_character +ElementInfo/dataType elementInfo_dataType +TaggedElement/content taggedElement_content +CategoryInfo/category categoryInfo_category +TermListDetails/attributes termListDetails_attributes +AttributeSetInfo/attributes attributeSetInfo_attributes +ExtendedServicesRequest/description extendedServicesRequest_description + +#.END + +#.REGISTER +Explain-Record B "1.2.840.10003.5.100" "Explain-record" +SutrsRecord B "1.2.840.10003.5.101" "Sutrs-record" +OPACRecord B "1.2.840.10003.5.102" "OPAC-record" +BriefBib B "1.2.840.10003.5.103" "Summary-record" +GenericRecord B "1.2.840.10003.5.105" "GRS-1-record" +TaskPackage B "1.2.840.10003.5.106" "ESTaskPackage" +DiagnosticFormat B "1.2.840.10003.4.2" "diag-1" +PromptObject B "1.2.840.10003.8.1" "Prompt-1" +DES-RN-Object B "1.2.840.10003.8.2" "DES-1" +KRBObject B "1.2.840.10003.8.3" "KRB-1" +SearchInfoReport B "1.2.840.10003.10.1" "SearchResult-1" +OCLC-UserInformation B "1.2.840.10003.10.1000.17.1" "OCLC-UserInfo-1" + +#.FN_HDR PDU + gint choice; +#.FN_PARS PDU VAL_PTR=&choice +#.FN_FTR PDU + if (choice >= 0) { + packet_info *pinfo = actx->pinfo; + gint32 tag = PDU_choice[choice].tag; + + col_set_str(pinfo->cinfo, COL_INFO, + val_to_str_const(tag, z3950_PDU_vals, "Unknown Z39.50 PDU")); + } + +#.FN_BODY Query/type-0 +/*XXX Not implemented yet */ + +#.FN_BODY ReferenceId + offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset, + hf_index, BER_CLASS_CON, 2, TRUE, + dissect_z3950_printable_OCTET_STRING); + +#.FN_BODY Term/general + offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset, + hf_index, BER_CLASS_CON, 2, TRUE, + dissect_z3950_printable_OCTET_STRING); + +#.FN_HDR AttributeSetId + tvbuff_t *oid_tvb=NULL; + +#.FN_PARS AttributeSetId VAL_PTR=&oid_tvb +#.FN_FTR AttributeSetId + if (oid_tvb) { + guint len = tvb_reported_length_remaining(oid_tvb, 0); + gchar *oid_str = oid_encoded2string(wmem_packet_scope(), + tvb_get_ptr(oid_tvb, 0, len), len); + gint attribute_set_idx = Z3950_ATSET_UNKNOWN; + z3950_atinfo_t *atinfo_data; + packet_info *pinfo = actx->pinfo; + + if (g_strcmp0(oid_str, Z3950_ATSET_BIB1_OID) == 0) { + attribute_set_idx = Z3950_ATSET_BIB1; + } + if ((atinfo_data = (z3950_atinfo_t *)p_get_proto_data(pinfo->pool, pinfo, proto_z3950, Z3950_ATINFO_KEY)) == NULL) { + + atinfo_data = wmem_new0(pinfo->pool, z3950_atinfo_t); + atinfo_data->atsetidx = attribute_set_idx; + p_add_proto_data(pinfo->pool, pinfo, + proto_z3950, Z3950_ATINFO_KEY, atinfo_data); + } + else { + atinfo_data->atsetidx = attribute_set_idx; + } + } + +#.FN_HDR AttributeElement/attributeType + gint att_type=0; + packet_info *pinfo = actx->pinfo; + z3950_atinfo_t *atinfo_data; +#.FN_PARS AttributeElement/attributeType VAL_PTR=&att_type +#.FN_FTR AttributeElement/attributeType + atinfo_data = (z3950_atinfo_t *)p_get_proto_data(pinfo->pool, pinfo, proto_z3950, Z3950_ATINFO_KEY); + if (atinfo_data && atinfo_data->atsetidx == Z3950_ATSET_BIB1) { + proto_item_append_text(actx->created_item, " (%s)", + val_to_str(att_type, z3950_bib1_att_types, "Unknown bib-1 attributeType %d")); + atinfo_data->attype = att_type; + } +#.FN_HDR AttributeElement/attributeValue/numeric + gint att_value=0; + packet_info *pinfo = actx->pinfo; + z3950_atinfo_t *atinfo_data; + const value_string *att_value_string = NULL; +#.FN_PARS AttributeElement/attributeValue/numeric VAL_PTR=&att_value +#.FN_FTR AttributeElement/attributeValue/numeric + atinfo_data = (z3950_atinfo_t *)p_get_proto_data(pinfo->pool, pinfo, proto_z3950, Z3950_ATINFO_KEY); + if (atinfo_data && atinfo_data->atsetidx == Z3950_ATSET_BIB1) { + switch (atinfo_data->attype) { + case Z3950_BIB1_AT_USE: + att_value_string = z3950_bib1_at_use; + break; + case Z3950_BIB1_AT_RELATION: + att_value_string = z3950_bib1_at_relation; + break; + case Z3950_BIB1_AT_POSITION: + att_value_string = z3950_bib1_at_position; + break; + case Z3950_BIB1_AT_STRUCTURE: + att_value_string = z3950_bib1_at_structure; + break; + case Z3950_BIB1_AT_TRUNCATION: + att_value_string = z3950_bib1_at_truncation; + break; + case Z3950_BIB1_AT_COMPLETENESS: + att_value_string = z3950_bib1_at_completeness; + break; + default: + att_value_string = NULL; + } + if (att_value_string) { + proto_item_append_text(actx->created_item, " (%s)", + val_to_str(att_value, att_value_string, "Unknown bib-1 attributeValue %d")); + } + } +#.FN_HDR DefaultDiagFormat/diagnosticSetId + tvbuff_t *oid_tvb=NULL; + +#.FN_PARS DefaultDiagFormat/diagnosticSetId VAL_PTR=&oid_tvb +#.FN_FTR DefaultDiagFormat/diagnosticSetId + if (oid_tvb) { + guint len = tvb_reported_length_remaining(oid_tvb, 0); + gchar *oid_str = oid_encoded2string(wmem_packet_scope(), + tvb_get_ptr(oid_tvb, 0, len), len); + gint diagset_idx = Z3950_DIAGSET_UNKNOWN; + z3950_diaginfo_t *diaginfo_data; + packet_info *pinfo = actx->pinfo; + + if (g_strcmp0(oid_str, Z3950_DIAGSET_BIB1_OID) == 0) { + diagset_idx = Z3950_DIAGSET_BIB1; + } + if ((diaginfo_data = (z3950_diaginfo_t *)p_get_proto_data(pinfo->pool, pinfo, proto_z3950, Z3950_DIAGSET_KEY)) == NULL) { + + diaginfo_data = wmem_new0(pinfo->pool, z3950_diaginfo_t); + diaginfo_data->diagsetidx = diagset_idx; + p_add_proto_data(pinfo->pool, pinfo, + proto_z3950, Z3950_DIAGSET_KEY, diaginfo_data); + } + else { + diaginfo_data->diagsetidx = diagset_idx; + } + } + +#.FN_HDR DefaultDiagFormat/condition + gint diag_condition=0; + packet_info *pinfo = actx->pinfo; + z3950_diaginfo_t *diaginfo_data; +#.FN_PARS DefaultDiagFormat/condition VAL_PTR=&diag_condition +#.FN_FTR DefaultDiagFormat/condition + diaginfo_data = (z3950_diaginfo_t *)p_get_proto_data(pinfo->pool, pinfo, proto_z3950, Z3950_DIAGSET_KEY); + if (diaginfo_data && diaginfo_data->diagsetidx == Z3950_DIAGSET_BIB1) { + proto_item_append_text(actx->created_item, " (%s)", + val_to_str(diag_condition, z3950_bib1_diagconditions, "Unknown bib-1 diagnostic %d")); + diaginfo_data->diagcondition = diag_condition; + } +# +# Editor modelines - http://www.wireshark.org/tools/modelines.html +# +# Local variables: +# c-basic-offset: 2 +# tab-width: 8 +# indent-tabs-mode: nil +# End: +# +# vi: set shiftwidth=2 tabstop=8 expandtab autoindent: +# :indentSize=2:tabSize=8:noTabs=true: +# diff --git a/epan/dissectors/packet-z3950.c b/epan/dissectors/packet-z3950.c new file mode 100644 index 0000000000..064fd88a2d --- /dev/null +++ b/epan/dissectors/packet-z3950.c @@ -0,0 +1,13065 @@ +/* Do not modify this file. Changes will be overwritten. */ +/* Generated automatically by the ASN.1 to Wireshark dissector compiler */ +/* packet-z3950.c */ +/* asn2wrs.py -b -p z3950 -c ./z3950.cnf -s ./packet-z3950-template -D . -O ../.. z3950.asn z3950-oclc.asn z3950-externals.asn */ + +/* Input file: packet-z3950-template.c */ + +#line 1 "./asn1/z3950/packet-z3950-template.c" +/* packet-z3950.c + * Routines for dissection of the NISO Z39.50 Information Retrieval protocol + * Also contains a dissector for the MARC Machine Readable Cataloging file + * format. The general format is specified by ISO 2709 and the specific + * instance is MARC21. + * + * Copyright 2018, Craig Jackson <cejackson51@gmail.com> + * + * Wireshark - Network traffic analyzer + * By Gerald Combs <gerald@wireshark.org> + * Copyright 1998 Gerald Combs + * + * SPDX-License-Identifier: GPL-2.0-or-later + * + * References: + * ISO 2709: https://www.iso.org/standard/41319.html + * MARC21: http://www.loc.gov/marc/bibliographic/ + * Z39.50 Maintenance Agency: http://www.loc.gov/z3950/agency/ + * Z39.50 2003 standard: http://www.loc.gov/z3950/agency/Z39-50-2003.pdf + * Z39.50 1995 ASN.1: https://www.loc.gov/z3950/agency/asn1.html + * Registered Z39.50 Object Identifiers: + * http://www.loc.gov/z3950/agency/defns/oids.html + * Bib-1 Attribute Set: https://www.loc.gov/z3950/agency/defns/bib1.html + * Bib-1 Diagnostics: https://www.loc.gov/z3950/agency/defns/bib1diag.html + * RFC for Z39.50 over TCP/IP: https://tools.ietf.org/html/rfc1729 + * + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <glib.h> +#include <epan/packet.h> +#include <epan/conversation.h> +#include <epan/exceptions.h> +#include <epan/expert.h> +#include <epan/oids.h> +#include <epan/proto_data.h> +#include <wsutil/str_util.h> + +#include <stdio.h> +#include <string.h> + +#include "packet-ber.h" +#include "packet-tcp.h" + +typedef struct z3950_atinfo_t { + gint atsetidx; + gint attype; +} z3950_atinfo_t; + +typedef struct z3950_diaginfo_t { + gint diagsetidx; + gint diagcondition; +} z3950_diaginfo_t; + +#define PNAME "Z39.50 Protocol" +#define PSNAME "Z39.50" +#define PFNAME "z3950" +#define Z3950_PORT 210 /* UDP port */ + +/* Known attribute set ids */ +#define Z3950_ATSET_BIB1_OID "1.2.840.10003.3.1" + +/* Known diagnostic set ids */ +#define Z3950_DIAGSET_BIB1_OID "1.2.840.10003.4.1" + +/* Known record syntax ids */ +#define Z3950_RECORDSYNTAX_MARC21_OID "1.2.840.10003.5.10" + +/* Indexes of known attribute set ids */ +#define Z3950_ATSET_UNKNOWN 0 +#define Z3950_ATSET_BIB1 1 + +/* bib-1 Attribute Types */ +#define Z3950_BIB1_AT_USE 1 +#define Z3950_BIB1_AT_RELATION 2 +#define Z3950_BIB1_AT_POSITION 3 +#define Z3950_BIB1_AT_STRUCTURE 4 +#define Z3950_BIB1_AT_TRUNCATION 5 +#define Z3950_BIB1_AT_COMPLETENESS 6 + +/* Indexes of known diagnostic set ids */ +#define Z3950_DIAGSET_UNKNOWN 0 +#define Z3950_DIAGSET_BIB1 1 + +/* Per-packet data keys */ +#define Z3950_ATINFO_KEY 1 +#define Z3950_DIAGSET_KEY 2 + +/* MARC defines */ +#define MARC_SUBFIELD_INDICATOR '\x1f' +#define MARC_LEADER_LENGTH 24 +#define MARC_CHAR_UNINITIALIZED 256 + +#define marc_isdigit(x) (((x) >='0') && ((x) <= '9')) +#define marc_char_to_int(x) ((x) - '0') + +typedef struct marc_directory_entry { + guint32 tag; + guint32 length; + guint32 starting_character; +} marc_directory_entry; + +static dissector_handle_t z3950_handle=NULL; + +void proto_reg_handoff_z3950(void); +void proto_register_z3950(void); + +/* Initialize the protocol and registered fields */ +static int proto_z3950 = -1; +static int global_z3950_port = Z3950_PORT; +static gboolean z3950_desegment = TRUE; + +static const value_string z3950_bib1_att_types[] = { + { Z3950_BIB1_AT_USE, "Use" }, + { Z3950_BIB1_AT_RELATION, "Relation" }, + { Z3950_BIB1_AT_POSITION, "Position" }, + { Z3950_BIB1_AT_STRUCTURE, "Structure" }, + { Z3950_BIB1_AT_TRUNCATION, "Truncation" }, + { Z3950_BIB1_AT_COMPLETENESS, "Completeness"}, + { 0, NULL} +}; + +static const value_string z3950_bib1_at_use[] = { + { 1, "Personal name" }, + { 2, "Corporate name" }, + { 3, "Conference name" }, + { 4, "Title" }, + { 5, "Title series" }, + { 6, "Title uniform" }, + { 7, "ISBN" }, + { 8, "ISSN" }, + { 9, "LC card number" }, + { 10, "BNB card number" }, + { 11, "BGF card number" }, + { 12, "Local number" }, + { 13, "Dewey classification" }, + { 14, "UDC classification" }, + { 15, "Bliss classification" }, + { 16, "LC call number" }, + { 17, "NLM call number" }, + { 18, "NAL call number" }, + { 19, "MOS call number" }, + { 20, "Local classification" }, + { 21, "Subject heading" }, + { 22, "Subject Rameau" }, + { 23, "BDI index subject" }, + { 24, "INSPEC subject" }, + { 25, "MESH subject" }, + { 26, "PA subject" }, + { 27, "LC subject heading" }, + { 28, "RVM subject heading" }, + { 29, "Local subject index" }, + { 30, "Date" }, + { 31, "Date of publication" }, + { 32, "Date of acquisition" }, + { 33, "Title key" }, + { 34, "Title collective" }, + { 35, "Title parallel" }, + { 36, "Title cover" }, + { 37, "Title added title pagw" }, + { 38, "Title caption" }, + { 39, "Title running" }, + { 40, "Title spine" }, + { 41, "Title other variant" }, + { 42, "Title former" }, + { 43, "Title abbreviated" }, + { 44, "Title expanded" }, + { 45, "Subject precis" }, + { 46, "Subject rswk" }, + { 47, "Subject subdivision" }, + { 48, "No. nat'l biblio." }, + { 49, "No. legal deposit" }, + { 50, "No. govt pub." }, + { 51, "No. music publisher" }, + { 52, "Number db" }, + { 53, "Number local call" }, + { 54, "Code-language" }, + { 55, "Code-geographic area" }, + { 56, "Code-institution" }, + { 57, "Name and title *" }, + { 58, "Name geographic" }, + { 59, "Place publication" }, + { 60, "CODEN" }, + { 61, "Microform generation" }, + { 62, "Abstract" }, + { 63, "Note" }, + { 1000, "Author-title" }, + { 1001, "Record type" }, + { 1002, "Name" }, + { 1003, "Author" }, + { 1004, "Author-name personal" }, + { 1005, "Author-name corporate" }, + { 1006, "Author-name conference" }, + { 1007, "Identifier-standard" }, + { 1008, "Subject-LC children's" }, + { 1009, "Subject name-personal" }, + { 1010, "Body of text" }, + { 1011, "Date/time added to db" }, + { 1012, "Date/time last modified" }, + { 1013, "Authority/format id" }, + { 1014, "Concept-text" }, + { 1015, "Concept-reference" }, + { 1016, "Any" }, + { 1017, "Server-choice" }, + { 1018, "Publisher" }, + { 1019, "Record-source" }, + { 1020, "Editor" }, + { 1021, "Bib-level" }, + { 1022, "Geographic class" }, + { 1023, "Indexed-by" }, + { 1024, "Map-scale" }, + { 1025, "Music-key" }, + { 1026, "Related-periodical" }, + { 1027, "Report-number" }, + { 1028, "Stock-number" }, + { 1030, "Thematic-number" }, + { 1031, "Material-type" }, + { 1032, "Doc-id" }, + { 1033, "Host-item" }, + { 1034, "Content-type" }, + { 1035, "Anywhere" }, + { 1036, "Author-Title-Subject" }, + { 1037, "Serial Item and Contribution Identifer (SICI)" }, + { 1038, "Abstract-language" }, + { 1039, "Application-kind" }, + { 1040, "Classification" }, + { 1041, "Classification-basic" }, + { 1042, "Classification-local-record" }, + { 1043, "Enzyme" }, + { 1044, "Possessing-institution" }, + { 1045, "Record-linking" }, + { 1046, "Record-status" }, + { 1047, "Treatment" }, + { 1048, "Control-number-GKD" }, + { 1049, "Control-number-linking" }, + { 1050, "Control-number-PND" }, + { 1051, "Control-number-SWD" }, + { 1052, "Control-number-ZDB" }, + { 1053, "Country-publication" }, + { 1054, "Date-conference" }, + { 1055, "Date-record-status" }, + { 1056, "Dissertation-information" }, + { 1057, "Meeting-organizer" }, + { 1058, "Note-availability" }, + { 1059, "Number-CAS-registry" }, + { 1060, "Number-document" }, + { 1061, "Number-local-accounting" }, + { 1062, "Number-local-acquisition" }, + { 1063, "Number-local-call-copy-specific" }, + { 1064, "Number-of-reference" }, + { 1065, "Number-norm" }, + { 1066, "Number-volume" }, + { 1067, "Place-conference (meeting location)" }, + { 1068, "Reference (references and footnotes)" }, + { 1069, "Referenced-journal" }, + { 1070, "Section-code" }, + { 1071, "Section-heading" }, + { 1072, "Subject-GOO" }, + { 1073, "Subject-name-conference" }, + { 1074, "Subject-name-corporate" }, + { 1075, "Subject-genre/form" }, + { 1076, "Subject-name-geographical" }, + { 1077, "Subject-chronological" }, + { 1078, "Subject-title" }, + { 1079, "Subject-topical" }, + { 1080, "Subject-uncontrolled" }, + { 1081, "Terminology-chemical" }, + { 1082, "Title-translated" }, + { 1083, "Year-of-beginning" }, + { 1084, "Year-of-ending" }, + { 1085, "Subject-AGROVOC" }, + { 1086, "Subject-COMPASS" }, + { 1087, "Subject-EPT" }, + { 1088, "Subject-NAL" }, + { 1089, "Classification-BCM" }, + { 1090, "Classification-DB" }, + { 1091, "Identifier-ISRC" }, + { 1092, "Identifier-ISMN" }, + { 1093, "Identifier-ISRN" }, + { 1094, "Identifier-DOI" }, + { 1095, "Code-language-original" }, + { 1096, "Title-later" }, + { 1097, "DC-Title" }, + { 1098, "DC-Creator" }, + { 1099, "DC-Subject" }, + { 1100, "DC-Description" }, + { 1101, "DC-Publisher" }, + { 1102, "DC-Date" }, + { 1103, "DC-ResourceType" }, + { 1104, "DC-ResourceIdentifier" }, + { 1105, "DC-Language" }, + { 1106, "DC-OtherContributor" }, + { 1107, "DC-Format" }, + { 1108, "DC-Source" }, + { 1109, "DC-Relation" }, + { 1110, "DC-Coverage" }, + { 1111, "DC-RightsManagment" }, + { 1112, "GILS Controlled Subject Index" }, + { 1113, "GILS Subject Thesaurus" }, + { 1114, "GILS Index Terms -- Controlled" }, + { 1115, "GILS Controlled Term" }, + { 1116, "GILS Spacial Domain" }, + { 1117, "GILS Bounding Coordinates" }, + { 1118, "GILS West Bounding Coordinate" }, + { 1119, "GILS East Bounding Coordinate" }, + { 1120, "GILS North Bounding Coordinate" }, + { 1121, "GILS South Bounding Coordinate" }, + { 1122, "GILS Place" }, + { 1123, "GILS Place Keyword Thesaurus" }, + { 1124, "GILS Place Keyword" }, + { 1125, "GILS Time Period" }, + { 1126, "GILS Time Period Textual" }, + { 1127, "GILS Time Period Structured" }, + { 1128, "GILS Beginning Date" }, + { 1129, "GILS Ending Date" }, + { 1130, "GILS Availability" }, + { 1131, "GILS Distributor" }, + { 1132, "GILS Distributor Name" }, + { 1133, "GILS Distributor Organization" }, + { 1134, "GILS Distributor Street Address" }, + { 1135, "GILS Distributor City" }, + { 1136, "GILS Distributor State or Province" }, + { 1137, "GILS Distributor Zip or Postal Code" }, + { 1138, "GILS Distributor Country" }, + { 1139, "GILS Distributor Network Address" }, + { 1140, "GILS Distributor Hours of Service" }, + { 1141, "GILS Distributor Telephone" }, + { 1142, "GILS Distributor Fax" }, + { 1143, "GILS Resource Description" }, + { 1144, "GILS Order Process" }, + { 1145, "GILS Order Information" }, + { 1146, "GILS Cost" }, + { 1147, "GILS Cost Information" }, + { 1148, "GILS Technical Prerequisites" }, + { 1149, "GILS Available Time Period" }, + { 1150, "GILS Available Time Textual" }, + { 1151, "GILS Available Time Structured" }, + { 1152, "GILS Available Linkage" }, + { 1153, "GILS Linkage Type" }, + { 1154, "GILS Linkage" }, + { 1155, "GILS Sources of Data" }, + { 1156, "GILS Methodology" }, + { 1157, "GILS Access Constraints" }, + { 1158, "GILS General Access Constraints" }, + { 1159, "GILS Originator Dissemination Control" }, + { 1160, "GILS Security Classification Control" }, + { 1161, "GILS Use Constraints" }, + { 1162, "GILS Point of Contact" }, + { 1163, "GILS Contact Name" }, + { 1164, "GILS Contact Organization" }, + { 1165, "GILS Contact Street Address" }, + { 1166, "GILS Contact City" }, + { 1167, "GILS Contact State or Province" }, + { 1168, "GILS Contact Zip or Postal Code" }, + { 1169, "GILS Contact Country" }, + { 1170, "GILS Contact Network Address" }, + { 1171, "GILS Contact Hours of Service" }, + { 1172, "GILS Contact Telephone" }, + { 1173, "GILS Contact Fax" }, + { 1174, "GILS Supplemental Information" }, + { 1175, "GILS Purpose" }, + { 1176, "GILS Agency Program" }, + { 1177, "GILS Cross Reference" }, + { 1178, "GILS Cross Reference Title" }, + { 1179, "GILS Cross Reference Relationship" }, + { 1180, "GILS Cross Reference Linkage" }, + { 1181, "GILS Schedule Number" }, + { 1182, "GILS Original Control Identifier" }, + { 1183, "GILS Language of Record" }, + { 1184, "GILS Record Review Date" }, + { 1185, "Performer" }, + { 1186, "Performer-Individual" }, + { 1187, "Performer-Group" }, + { 1188, "Instrumentation" }, + { 1189, "Instrumentation-Original" }, + { 1190, "Instrumentation-Current" }, + { 1191, "Arrangement" }, + { 1192, "Arrangement-Original" }, + { 1193, "Arrangement-Current" }, + { 1194, "Musical Key-Original" }, + { 1195, "Musical Key-Current" }, + { 1196, "Date-Composition" }, + { 1197, "Date-Recording" }, + { 1198, "Place-Recording" }, + { 1199, "Country-Recording" }, + { 1200, "Number-ISWC" }, + { 1201, "Number-Matrix" }, + { 1202, "Number-Plate" }, + { 1203, "Classification-McColvin" }, + { 1204, "Duration" }, + { 1205, "Number-Copies" }, + { 1206, "Musical Theme" }, + { 1207, "Instruments - total number" }, + { 1208, "Instruments - distinct number" }, + { 1209, "Identifier - URN" }, + { 1210, "Sears Subject Heading" }, + { 1211, "OCLC Number" }, + { 1212, "NORZIG Composition" }, + { 1213, "NORZIG Intellectual level" }, + { 1214, "NORZIG EAN" }, + { 1215, "NORZIG NLC" }, + { 1216, "NORZIG CRCS" }, + { 1217, "NORZIG Nationality" }, + { 1218, "NORZIG Equinox" }, + { 1219, "NORZIG Compression" }, + { 1220, "NORZIG Format" }, + { 1221, "NORZIG Subject - occupation" }, + { 1222, "NORZIG Subject - function" }, + { 1223, "NORZIG Edition" }, + { 1224, "GPO Item Number" }, + { 1225, "Provider" }, + { 0, NULL} +}; + +static const value_string z3950_bib1_at_relation[] = { + { 1, "Less than" }, + { 2, "Less than or equal" }, + { 3, "Equal" }, + { 4, "Greater than or equal" }, + { 5, "Greater than" }, + { 6, "Not equal" }, + { 100, "Phonetic" }, + { 101, "Stem" }, + { 102, "Relevance" }, + { 103, "Always Matches" }, + { 0, NULL} +}; + +static const value_string z3950_bib1_at_position[] = { + { 1, "First in field" }, + { 2, "First in subfield" }, + { 3, "Any position in field" }, + { 0, NULL} +}; + +static const value_string z3950_bib1_at_structure[] = { + { 1, "Phrase" }, + { 2, "Word" }, + { 3, "Key" }, + { 4, "Year" }, + { 5, "Date (normalized)" }, + { 6, "Word list" }, + { 100, "Date (un-normalized)" }, + { 101, "Name (normalized)" }, + { 102, "Name (un-normalized)" }, + { 103, "Structure" }, + { 104, "Urx" }, + { 105, "Free-form-text" }, + { 106, "Document-text" }, + { 107, "Local" }, + { 108, "String" }, + { 109, "Numeric" }, + { 0, NULL} +}; + +static const value_string z3950_bib1_at_truncation[] = { + { 1, "Right truncation" }, + { 2, "Left truncation" }, + { 3, "Left and right truncation" }, + { 100, "Do not truncate" }, + { 101, "Process # in search term" }, + { 102, "regExpr-1" }, + { 103, "regExpr-2" }, + { 104, "Z39.58-1992 Character masking" }, + { 0, NULL} +}; + +static const value_string z3950_bib1_at_completeness[] = { + { 1, "Incomplete subfield" }, + { 2, "Complete subfield" }, + { 3, "Complete field" }, + { 0, NULL} +}; + +static const value_string z3950_bib1_diagconditions[] = { + { 1, "Permanent system error" }, + { 2, "Temporary system error" }, + { 3, "Unsupported search" }, + { 4, "Terms only exclusion (stop) words" }, + { 5, "Too many argument words" }, + { 6, "Too many boolean operators" }, + { 7, "Too many truncated words" }, + { 8, "Too many incomplete subfields" }, + { 9, "Truncated words too short" }, + { 10, "Invalid format for record number (search term)" }, + { 11, "Too many characters in search statement" }, + { 12, "Too many records retrieved" }, + { 13, "Present request out of range" }, + { 14, "System error in presenting records" }, + { 15, "Record no authorized to be sent intersystem" }, + { 16, "Record exceeds Preferred-message-size" }, + { 17, "Record exceeds Maximum-record-size" }, + { 18, "Result set not supported as a search term" }, + { 19, "Only single result set as search term supported" }, + { 20, "Only ANDing of a single result set as search term supported" }, + { 21, "Result set exists and replace indicator off" }, + { 22, "Result set naming not supported" }, + { 23, "Combination of specified databases not supported" }, + { 24, "Element set names not supported" }, + { 25, "Specified element set name not valid for specified database" }, + { 26, "Only a single element set name supported" }, + { 27, "Result set no longer exists - unilaterally deleted by target" }, + { 28, "Result set is in use" }, + { 29, "One of the specified databases is locked" }, + { 30, "Specified result set does not exist" }, + { 31, "Resources exhausted - no results available" }, + { 32, "Resources exhausted - unpredictable partial results available" }, + { 33, "Resources exhausted - valid subset of results available" }, + { 100, "Unspecified error" }, + { 101, "Access-control failure" }, + { 102, "Security challenge required but could not be issued - request terminated" }, + { 103, "Security challenge required but could not be issued - record not included" }, + { 104, "Security challenge failed - record not included" }, + { 105, "Terminated by negative continue response" }, + { 106, "No abstract syntaxes agreed to for this record" }, + { 107, "Query type not supported" }, + { 108, "Malformed query" }, + { 109, "Database unavailable" }, + { 110, "Operator unsupported" }, + { 111, "Too many databases specified" }, + { 112, "Too many result sets created" }, + { 113, "Unsupported attribute type" }, + { 114, "Unsupported Use attribute" }, + { 115, "Unsupported value for Use attribute" }, + { 116, "Use attribute required but not supplied" }, + { 117, "Unsupported Relation attribute" }, + { 118, "Unsupported Structure attribute" }, + { 119, "Unsupported Position attribute" }, + { 120, "Unsupported Truncation attribute" }, + { 121, "Unsupported Attribute Set" }, + { 122, "Unsupported Completeness attribute" }, + { 123, "Unsupported attribute combination" }, + { 124, "Unsupported coded value for term" }, + { 125, "Malformed search term" }, + { 126, "Illegal term value for attribute" }, + { 127, "Unparsable format for un-normalized value" }, + { 128, "Illegal result set name" }, + { 129, "Proximity search of sets not supported" }, + { 130, "Illegal result set in proximity search" }, + { 131, "Unsupported proximity relation" }, + { 132, "Unsupported proximity unit code" }, + { 201, "Proximity not supported with this attribute combination" }, + { 202, "Unsupported distance for proximity" }, + { 203, "Ordered flag not supported for proximity" }, + { 205, "Only zero step size supported for Scan" }, + { 206, "Specified step size not supported for Scan" }, + { 207, "Cannot sort according to sequence" }, + { 208, "No result set name supplied on Sort" }, + { 209, "Generic sort not supported (database-specific sort only supported)" }, + { 210, "Database specific sort not supported" }, + { 211, "Too many sort keys" }, + { 212, "Duplicate sort keys" }, + { 213, "Unsupported missing data action" }, + { 214, "Illegal sort relation" }, + { 215, "Illegal case value" }, + { 216, "Illegal missing data action" }, + { 217, "Segmentation: Cannot guarantee records will fit in specified segments" }, + { 218, "ES: Package name already in use" }, + { 219, "ES: no such package, on modify/delete" }, + { 220, "ES: quota exceeded" }, + { 221, "ES: extended service type not supported" }, + { 222, "ES: permission denied on ES - id not authorized" }, + { 223, "ES: permission denied on ES - cannot modify or delete" }, + { 224, "ES: immediate execution failed" }, + { 225, "ES: immediate execution not supported for this service" }, + { 226, "ES: immediate execution not supported for these parameters" }, + { 227, "No data available in requested record syntax" }, + { 228, "Scan: malformed scan" }, + { 229, "Term type not supported" }, + { 230, "Sort: too many input results" }, + { 231, "Sort: incompatible record formats" }, + { 232, "Scan: term list not supported" }, + { 233, "Scan: unsupported value of position-in-response" }, + { 234, "Too many index terms processed" }, + { 235, "Database does not exist" }, + { 236, "Access to specified database denied" }, + { 237, "Sort: illegal sort" }, + { 238, "Record not available in requested syntax" }, + { 239, "Record syntax not supported" }, + { 240, "Scan: Resources exhausted looking for satisfying terms" }, + { 241, "Scan: Beginning or end of term list" }, + { 242, "Segmentation: max-segment-size too small to segment record" }, + { 243, "Present: additional-ranges parameter not supported" }, + { 244, "Present: comp-spec parameter not supported" }, + { 245, "Type-1 query: restriction ('resultAttr') operand not supported" }, + { 246, "Type-1 query: 'complex' attributeValue not supported" }, + { 247, "Type-1 query: 'attributeSet' as part of AttributeElement not supported" }, + { 1001, "Malformed APDU" }, + { 1002, "ES: EXTERNAL form of Item Order request not supported" }, + { 1003, "ES: Result set item form of Item Order request not supported" }, + { 1004, "ES: Extended services not supported unless access control is in effect" }, + { 1005, "Response records in Search response not supported" }, + { 1006, "Response records in Search response not possible for specified database (or database combination)" }, + { 1007, "No Explain server. Addinfo: pointers to servers that have a surrogate Explain database for this server" }, + { 1008, "ES: missing mandatory parameter for specified function. Addinfo: parameter" }, + { 1009, "ES: Item Order, unsupported OID in itemRequest. Addinfo: OID" }, + { 1010, "Init/AC: Bad Userid" }, + { 1011, "Init/AC: Bad Userid and/or Password" }, + { 1012, "Init/AC: No searches remaining (pre-purchased searches exhausted)" }, + { 1013, "Init/AC: Incorrect interface type (specified id valid only when used with a particular access method or client)" }, + { 1014, "Init/AC: Authentication System error" }, + { 1015, "Init/AC: Maximum number of simultaneous sessions for Userid" }, + { 1016, "Init/AC: Blocked network address" }, + { 1017, "Init/AC: No databases available for specified userId" }, + { 1018, "Init/AC: System temporarily out of resources" }, + { 1019, "Init/AC: System not available due to maintenance" }, + { 1020, "Init/AC: System temporarily unavailable (Addinfo: when it's expected back up)" }, + { 1021, "Init/AC: Account has expired" }, + { 1022, "Init/AC: Password has expired so a new one must be supplied" }, + { 1023, "Init/AC: Password has been changed by an administrator so a new one must be supplied" }, + { 1024, "Unsupported Attribute" }, + { 1025, "Service not supported for this database" }, + { 1026, "Record cannot be opened because it is locked" }, + { 1027, "SQL error" }, + { 1028, "Record deleted" }, + { 1029, "Scan: too many terms requested. Addinfo: max terms supported" }, + { 1040, "ES: Invalid function" }, + { 1041, "ES: Error in retention time" }, + { 1042, "ES: Permissions data not understood" }, + { 1043, "ES: Invalid OID for task specific parameters" }, + { 1044, "ES: Invalid action" }, + { 1045, "ES: Unknown schema" }, + { 1046, "ES: Too many records in package" }, + { 1047, "ES: Invalid wait action" }, + { 1048, "ES: Cannot create task package -- exceeds maximum permissable size" }, + { 1049, "ES: Cannot return task package -- exceeds maximum permissable size" }, + { 1050, "ES: Extended services request too large" }, + { 1051, "Scan: Attribute set id required -- not supplied" }, + { 1052, "ES: Cannot process task package record -- exceeds maximum permissible record size for ES" }, + { 1053, "ES: Cannot return task package record -- exceeds maximum permissible record size for ES response" }, + { 1054, "Init: Required negotiation record not included" }, + { 1055, "Init: negotiation option required" }, + { 1056, "Attribute not supported for database" }, + { 1057, "ES: Unsupported value of task package parameter" }, + { 1058, "Duplicate Detection: Cannot dedup on requested record portion" }, + { 1059, "Duplicate Detection: Requested detection criterion not supported" }, + { 1060, "Duplicate Detection: Requested level of match not supported" }, + { 1061, "Duplicate Detection: Requested regular expression not supported" }, + { 1062, "Duplicate Detection: Cannot do clustering" }, + { 1063, "Duplicate Detection: Retention criterion not supported" }, + { 1064, "Duplicate Detection: Requested number (or percentage) of entries for retention too large" }, + { 1065, "Duplicate Detection: Requested sort criterion not supported" }, + { 1066, "CompSpec: Unknown schema, or schema not supported." }, + { 1067, "Encapsulation: Encapsulated sequence of PDUs not supported" }, + { 1068, "Encapsulation: Base operation (and encapsulated PDUs) not executed based on pre-screening analysis" }, + { 1069, "No syntaxes available for this request" }, + { 1070, "user not authorized to receive record(s) in requested syntax" }, + { 1071, "preferredRecordSyntax not supplied" }, + { 1072, "Query term includes characters that do not translate into the target character set" }, + { 1073, "Database records do not contain data associated with access point" }, + { 1074, "Proxy failure" }, + { 0, NULL} +}; + + +/*--- Included file: packet-z3950-hf.c ---*/ +#line 1 "./asn1/z3950/packet-z3950-hf.c" +static int hf_z3950_OCLC_UserInformation_PDU = -1; /* OCLC_UserInformation */ +static int hf_z3950_SutrsRecord_PDU = -1; /* SutrsRecord */ +static int hf_z3950_OPACRecord_PDU = -1; /* OPACRecord */ +static int hf_z3950_DiagnosticFormat_PDU = -1; /* DiagnosticFormat */ +static int hf_z3950_Explain_Record_PDU = -1; /* Explain_Record */ +static int hf_z3950_BriefBib_PDU = -1; /* BriefBib */ +static int hf_z3950_GenericRecord_PDU = -1; /* GenericRecord */ +static int hf_z3950_TaskPackage_PDU = -1; /* TaskPackage */ +static int hf_z3950_PromptObject_PDU = -1; /* PromptObject */ +static int hf_z3950_DES_RN_Object_PDU = -1; /* DES_RN_Object */ +static int hf_z3950_KRBObject_PDU = -1; /* KRBObject */ +static int hf_z3950_SearchInfoReport_PDU = -1; /* SearchInfoReport */ +static int hf_z3950_initRequest = -1; /* InitializeRequest */ +static int hf_z3950_initResponse = -1; /* InitializeResponse */ +static int hf_z3950_searchRequest = -1; /* SearchRequest */ +static int hf_z3950_searchResponse = -1; /* SearchResponse */ +static int hf_z3950_presentRequest = -1; /* PresentRequest */ +static int hf_z3950_presentResponse = -1; /* PresentResponse */ +static int hf_z3950_deleteResultSetRequest = -1; /* DeleteResultSetRequest */ +static int hf_z3950_deleteResultSetResponse = -1; /* DeleteResultSetResponse */ +static int hf_z3950_accessControlRequest = -1; /* AccessControlRequest */ +static int hf_z3950_accessControlResponse = -1; /* AccessControlResponse */ +static int hf_z3950_resourceControlRequest = -1; /* ResourceControlRequest */ +static int hf_z3950_resourceControlResponse = -1; /* ResourceControlResponse */ +static int hf_z3950_triggerResourceControlRequest = -1; /* TriggerResourceControlRequest */ +static int hf_z3950_resourceReportRequest = -1; /* ResourceReportRequest */ +static int hf_z3950_resourceReportResponse = -1; /* ResourceReportResponse */ +static int hf_z3950_scanRequest = -1; /* ScanRequest */ +static int hf_z3950_scanResponse = -1; /* ScanResponse */ +static int hf_z3950_sortRequest = -1; /* SortRequest */ +static int hf_z3950_sortResponse = -1; /* SortResponse */ +static int hf_z3950_segmentRequest = -1; /* Segment */ +static int hf_z3950_extendedServicesRequest = -1; /* ExtendedServicesRequest */ +static int hf_z3950_extendedServicesResponse = -1; /* ExtendedServicesResponse */ +static int hf_z3950_close = -1; /* Close */ +static int hf_z3950_referenceId = -1; /* ReferenceId */ +static int hf_z3950_protocolVersion = -1; /* ProtocolVersion */ +static int hf_z3950_options = -1; /* Options */ +static int hf_z3950_preferredMessageSize = -1; /* INTEGER */ +static int hf_z3950_exceptionalRecordSize = -1; /* INTEGER */ +static int hf_z3950_idAuthentication = -1; /* T_idAuthentication */ +static int hf_z3950_open = -1; /* VisibleString */ +static int hf_z3950_idPass = -1; /* T_idPass */ +static int hf_z3950_groupId = -1; /* InternationalString */ +static int hf_z3950_userId = -1; /* InternationalString */ +static int hf_z3950_password = -1; /* InternationalString */ +static int hf_z3950_anonymous = -1; /* NULL */ +static int hf_z3950_other = -1; /* EXTERNAL */ +static int hf_z3950_implementationId = -1; /* InternationalString */ +static int hf_z3950_implementationName = -1; /* InternationalString */ +static int hf_z3950_implementationVersion = -1; /* InternationalString */ +static int hf_z3950_userInformationField = -1; /* EXTERNAL */ +static int hf_z3950_otherInfo = -1; /* OtherInformation */ +static int hf_z3950_result = -1; /* BOOLEAN */ +static int hf_z3950_smallSetUpperBound = -1; /* INTEGER */ +static int hf_z3950_largeSetLowerBound = -1; /* INTEGER */ +static int hf_z3950_mediumSetPresentNumber = -1; /* INTEGER */ +static int hf_z3950_replaceIndicator = -1; /* BOOLEAN */ +static int hf_z3950_resultSetName = -1; /* InternationalString */ +static int hf_z3950_databaseNames = -1; /* SEQUENCE_OF_DatabaseName */ +static int hf_z3950_databaseNames_item = -1; /* DatabaseName */ +static int hf_z3950_smallSetElementSetNames = -1; /* ElementSetNames */ +static int hf_z3950_mediumSetElementSetNames = -1; /* ElementSetNames */ +static int hf_z3950_preferredRecordSyntax = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_query = -1; /* Query */ +static int hf_z3950_additionalSearchInfo = -1; /* OtherInformation */ +static int hf_z3950_type_0 = -1; /* T_type_0 */ +static int hf_z3950_type_1 = -1; /* RPNQuery */ +static int hf_z3950_type_2 = -1; /* OCTET_STRING */ +static int hf_z3950_type_100 = -1; /* OCTET_STRING */ +static int hf_z3950_type_101 = -1; /* RPNQuery */ +static int hf_z3950_type_102 = -1; /* OCTET_STRING */ +static int hf_z3950_attributeSet = -1; /* AttributeSetId */ +static int hf_z3950_rpn = -1; /* RPNStructure */ +static int hf_z3950_operandRpnOp = -1; /* Operand */ +static int hf_z3950_rpnRpnOp = -1; /* T_rpnRpnOp */ +static int hf_z3950_rpn1 = -1; /* RPNStructure */ +static int hf_z3950_rpn2 = -1; /* RPNStructure */ +static int hf_z3950_operatorRpnOp = -1; /* Operator */ +static int hf_z3950_attrTerm = -1; /* AttributesPlusTerm */ +static int hf_z3950_resultSet = -1; /* ResultSetId */ +static int hf_z3950_resultAttr = -1; /* ResultSetPlusAttributes */ +static int hf_z3950_attributes = -1; /* AttributeList */ +static int hf_z3950_term = -1; /* Term */ +static int hf_z3950_attributeList_item = -1; /* AttributeElement */ +static int hf_z3950_general = -1; /* T_general */ +static int hf_z3950_numeric = -1; /* INTEGER */ +static int hf_z3950_characterString = -1; /* InternationalString */ +static int hf_z3950_oid = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_dateTime = -1; /* GeneralizedTime */ +static int hf_z3950_external = -1; /* EXTERNAL */ +static int hf_z3950_integerAndUnit = -1; /* IntUnit */ +static int hf_z3950_null = -1; /* NULL */ +static int hf_z3950_and = -1; /* NULL */ +static int hf_z3950_or = -1; /* NULL */ +static int hf_z3950_and_not = -1; /* NULL */ +static int hf_z3950_prox = -1; /* ProximityOperator */ +static int hf_z3950_attributeElement_attributeType = -1; /* T_attributeElement_attributeType */ +static int hf_z3950_attributeValue = -1; /* T_attributeValue */ +static int hf_z3950_attributeValue_numeric = -1; /* T_attributeValue_numeric */ +static int hf_z3950_attributeValue_complex = -1; /* T_attributeValue_complex */ +static int hf_z3950_attributeValue_complex_list = -1; /* SEQUENCE_OF_StringOrNumeric */ +static int hf_z3950_attributeValue_complex_list_item = -1; /* StringOrNumeric */ +static int hf_z3950_semanticAction = -1; /* T_semanticAction */ +static int hf_z3950_semanticAction_item = -1; /* INTEGER */ +static int hf_z3950_exclusion = -1; /* BOOLEAN */ +static int hf_z3950_distance = -1; /* INTEGER */ +static int hf_z3950_ordered = -1; /* BOOLEAN */ +static int hf_z3950_relationType = -1; /* T_relationType */ +static int hf_z3950_proximityUnitCode = -1; /* T_proximityUnitCode */ +static int hf_z3950_known = -1; /* KnownProximityUnit */ +static int hf_z3950_private = -1; /* INTEGER */ +static int hf_z3950_resultCount = -1; /* INTEGER */ +static int hf_z3950_numberOfRecordsReturned = -1; /* INTEGER */ +static int hf_z3950_nextResultSetPosition = -1; /* INTEGER */ +static int hf_z3950_searchStatus = -1; /* BOOLEAN */ +static int hf_z3950_search_resultSetStatus = -1; /* T_search_resultSetStatus */ +static int hf_z3950_presentStatus = -1; /* PresentStatus */ +static int hf_z3950_records = -1; /* Records */ +static int hf_z3950_resultSetId = -1; /* ResultSetId */ +static int hf_z3950_resultSetStartPoint = -1; /* INTEGER */ +static int hf_z3950_numberOfRecordsRequested = -1; /* INTEGER */ +static int hf_z3950_additionalRanges = -1; /* SEQUENCE_OF_Range */ +static int hf_z3950_additionalRanges_item = -1; /* Range */ +static int hf_z3950_recordComposition = -1; /* T_recordComposition */ +static int hf_z3950_simple = -1; /* ElementSetNames */ +static int hf_z3950_recordComposition_complex = -1; /* CompSpec */ +static int hf_z3950_maxSegmentCount = -1; /* INTEGER */ +static int hf_z3950_maxRecordSize = -1; /* INTEGER */ +static int hf_z3950_maxSegmentSize = -1; /* INTEGER */ +static int hf_z3950_segmentRecords = -1; /* SEQUENCE_OF_NamePlusRecord */ +static int hf_z3950_segmentRecords_item = -1; /* NamePlusRecord */ +static int hf_z3950_responseRecords = -1; /* SEQUENCE_OF_NamePlusRecord */ +static int hf_z3950_responseRecords_item = -1; /* NamePlusRecord */ +static int hf_z3950_nonSurrogateDiagnostic = -1; /* DefaultDiagFormat */ +static int hf_z3950_multipleNonSurDiagnostics = -1; /* SEQUENCE_OF_DiagRec */ +static int hf_z3950_multipleNonSurDiagnostics_item = -1; /* DiagRec */ +static int hf_z3950_namePlusRecord_name = -1; /* DatabaseName */ +static int hf_z3950_record = -1; /* T_record */ +static int hf_z3950_retrievalRecord = -1; /* EXTERNAL */ +static int hf_z3950_surrogateDiagnostic = -1; /* DiagRec */ +static int hf_z3950_startingFragment = -1; /* FragmentSyntax */ +static int hf_z3950_intermediateFragment = -1; /* FragmentSyntax */ +static int hf_z3950_finalFragment = -1; /* FragmentSyntax */ +static int hf_z3950_externallyTagged = -1; /* EXTERNAL */ +static int hf_z3950_notExternallyTagged = -1; /* OCTET_STRING */ +static int hf_z3950_defaultFormat = -1; /* DefaultDiagFormat */ +static int hf_z3950_externallyDefined = -1; /* EXTERNAL */ +static int hf_z3950_diagnosticSetId = -1; /* T_diagnosticSetId */ +static int hf_z3950_condition = -1; /* T_condition */ +static int hf_z3950_addinfo = -1; /* T_addinfo */ +static int hf_z3950_v2Addinfo = -1; /* VisibleString */ +static int hf_z3950_v3Addinfo = -1; /* InternationalString */ +static int hf_z3950_startingPosition = -1; /* INTEGER */ +static int hf_z3950_numberOfRecords = -1; /* INTEGER */ +static int hf_z3950_genericElementSetName = -1; /* InternationalString */ +static int hf_z3950_databaseSpecific = -1; /* T_databaseSpecific */ +static int hf_z3950_databaseSpecific_item = -1; /* T_databaseSpecific_item */ +static int hf_z3950_dbName = -1; /* DatabaseName */ +static int hf_z3950_esn = -1; /* ElementSetName */ +static int hf_z3950_selectAlternativeSyntax = -1; /* BOOLEAN */ +static int hf_z3950_compSpec_generic = -1; /* Specification */ +static int hf_z3950_dbSpecific = -1; /* T_dbSpecific */ +static int hf_z3950_dbSpecific_item = -1; /* T_dbSpecific_item */ +static int hf_z3950_db = -1; /* DatabaseName */ +static int hf_z3950_spec = -1; /* Specification */ +static int hf_z3950_compSpec_recordSyntax = -1; /* T_compSpec_recordSyntax */ +static int hf_z3950_compSpec_recordSyntax_item = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_schema = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_specification_elementSpec = -1; /* T_specification_elementSpec */ +static int hf_z3950_elementSetName = -1; /* InternationalString */ +static int hf_z3950_externalEspec = -1; /* EXTERNAL */ +static int hf_z3950_deleteFunction = -1; /* T_deleteFunction */ +static int hf_z3950_resultSetList = -1; /* SEQUENCE_OF_ResultSetId */ +static int hf_z3950_resultSetList_item = -1; /* ResultSetId */ +static int hf_z3950_deleteOperationStatus = -1; /* DeleteSetStatus */ +static int hf_z3950_deleteListStatuses = -1; /* ListStatuses */ +static int hf_z3950_numberNotDeleted = -1; /* INTEGER */ +static int hf_z3950_bulkStatuses = -1; /* ListStatuses */ +static int hf_z3950_deleteMessage = -1; /* InternationalString */ +static int hf_z3950_ListStatuses_item = -1; /* ListStatuses_item */ +static int hf_z3950_listStatuses_id = -1; /* ResultSetId */ +static int hf_z3950_status = -1; /* DeleteSetStatus */ +static int hf_z3950_securityChallenge = -1; /* T_securityChallenge */ +static int hf_z3950_simpleForm = -1; /* OCTET_STRING */ +static int hf_z3950_securityChallengeResponse = -1; /* T_securityChallengeResponse */ +static int hf_z3950_diagnostic = -1; /* DiagRec */ +static int hf_z3950_suspendedFlag = -1; /* BOOLEAN */ +static int hf_z3950_resourceReport = -1; /* ResourceReport */ +static int hf_z3950_partialResultsAvailable = -1; /* T_partialResultsAvailable */ +static int hf_z3950_resourceControlRequest_responseRequired = -1; /* BOOLEAN */ +static int hf_z3950_triggeredRequestFlag = -1; /* BOOLEAN */ +static int hf_z3950_continueFlag = -1; /* BOOLEAN */ +static int hf_z3950_resultSetWanted = -1; /* BOOLEAN */ +static int hf_z3950_requestedAction = -1; /* T_requestedAction */ +static int hf_z3950_prefResourceReportFormat = -1; /* ResourceReportId */ +static int hf_z3950_opId = -1; /* ReferenceId */ +static int hf_z3950_resourceReportStatus = -1; /* T_resourceReportStatus */ +static int hf_z3950_termListAndStartPoint = -1; /* AttributesPlusTerm */ +static int hf_z3950_stepSize = -1; /* INTEGER */ +static int hf_z3950_numberOfTermsRequested = -1; /* INTEGER */ +static int hf_z3950_preferredPositionInResponse = -1; /* INTEGER */ +static int hf_z3950_scanStatus = -1; /* T_scanStatus */ +static int hf_z3950_numberOfEntriesReturned = -1; /* INTEGER */ +static int hf_z3950_positionOfTerm = -1; /* INTEGER */ +static int hf_z3950_scanResponse_entries = -1; /* ListEntries */ +static int hf_z3950_listEntries_entries = -1; /* SEQUENCE_OF_Entry */ +static int hf_z3950_listEntries_entries_item = -1; /* Entry */ +static int hf_z3950_nonsurrogateDiagnostics = -1; /* SEQUENCE_OF_DiagRec */ +static int hf_z3950_nonsurrogateDiagnostics_item = -1; /* DiagRec */ +static int hf_z3950_termInfo = -1; /* TermInfo */ +static int hf_z3950_displayTerm = -1; /* InternationalString */ +static int hf_z3950_suggestedAttributes = -1; /* AttributeList */ +static int hf_z3950_alternativeTerm = -1; /* SEQUENCE_OF_AttributesPlusTerm */ +static int hf_z3950_alternativeTerm_item = -1; /* AttributesPlusTerm */ +static int hf_z3950_globalOccurrences = -1; /* INTEGER */ +static int hf_z3950_byAttributes = -1; /* OccurrenceByAttributes */ +static int hf_z3950_otherTermInfo = -1; /* OtherInformation */ +static int hf_z3950_OccurrenceByAttributes_item = -1; /* OccurrenceByAttributes_item */ +static int hf_z3950_occurrences = -1; /* T_occurrences */ +static int hf_z3950_global = -1; /* INTEGER */ +static int hf_z3950_byDatabase = -1; /* T_byDatabase */ +static int hf_z3950_byDatabase_item = -1; /* T_byDatabase_item */ +static int hf_z3950_num = -1; /* INTEGER */ +static int hf_z3950_otherDbInfo = -1; /* OtherInformation */ +static int hf_z3950_otherOccurInfo = -1; /* OtherInformation */ +static int hf_z3950_inputResultSetNames = -1; /* SEQUENCE_OF_InternationalString */ +static int hf_z3950_inputResultSetNames_item = -1; /* InternationalString */ +static int hf_z3950_sortedResultSetName = -1; /* InternationalString */ +static int hf_z3950_sortSequence = -1; /* SEQUENCE_OF_SortKeySpec */ +static int hf_z3950_sortSequence_item = -1; /* SortKeySpec */ +static int hf_z3950_sortStatus = -1; /* T_sortStatus */ +static int hf_z3950_sort_resultSetStatus = -1; /* T_sort_resultSetStatus */ +static int hf_z3950_diagnostics = -1; /* SEQUENCE_OF_DiagRec */ +static int hf_z3950_diagnostics_item = -1; /* DiagRec */ +static int hf_z3950_sortElement = -1; /* SortElement */ +static int hf_z3950_sortRelation = -1; /* T_sortRelation */ +static int hf_z3950_caseSensitivity = -1; /* T_caseSensitivity */ +static int hf_z3950_missingValueAction = -1; /* T_missingValueAction */ +static int hf_z3950_abort = -1; /* NULL */ +static int hf_z3950_missingValueData = -1; /* OCTET_STRING */ +static int hf_z3950_sortElement_generic = -1; /* SortKey */ +static int hf_z3950_datbaseSpecific = -1; /* T_datbaseSpecific */ +static int hf_z3950_datbaseSpecific_item = -1; /* T_datbaseSpecific_item */ +static int hf_z3950_databaseName = -1; /* DatabaseName */ +static int hf_z3950_dbSort = -1; /* SortKey */ +static int hf_z3950_sortfield = -1; /* InternationalString */ +static int hf_z3950_sortKey_elementSpec = -1; /* Specification */ +static int hf_z3950_sortAttributes = -1; /* T_sortAttributes */ +static int hf_z3950_sortAttributes_id = -1; /* AttributeSetId */ +static int hf_z3950_sortAttributes_list = -1; /* AttributeList */ +static int hf_z3950_function = -1; /* T_function */ +static int hf_z3950_packageType = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_packageName = -1; /* InternationalString */ +static int hf_z3950_retentionTime = -1; /* IntUnit */ +static int hf_z3950_permissions = -1; /* Permissions */ +static int hf_z3950_extendedServicesRequest_description = -1; /* InternationalString */ +static int hf_z3950_taskSpecificParameters = -1; /* EXTERNAL */ +static int hf_z3950_waitAction = -1; /* T_waitAction */ +static int hf_z3950_elements = -1; /* ElementSetName */ +static int hf_z3950_operationStatus = -1; /* T_operationStatus */ +static int hf_z3950_taskPackage = -1; /* EXTERNAL */ +static int hf_z3950_Permissions_item = -1; /* Permissions_item */ +static int hf_z3950_allowableFunctions = -1; /* T_allowableFunctions */ +static int hf_z3950_allowableFunctions_item = -1; /* T_allowableFunctions_item */ +static int hf_z3950_closeReason = -1; /* CloseReason */ +static int hf_z3950_diagnosticInformation = -1; /* InternationalString */ +static int hf_z3950_resourceReportFormat = -1; /* ResourceReportId */ +static int hf_z3950_otherInformation_item = -1; /* T__untag_item */ +static int hf_z3950_category = -1; /* InfoCategory */ +static int hf_z3950_information = -1; /* T_information */ +static int hf_z3950_characterInfo = -1; /* InternationalString */ +static int hf_z3950_binaryInfo = -1; /* OCTET_STRING */ +static int hf_z3950_externallyDefinedInfo = -1; /* EXTERNAL */ +static int hf_z3950_categoryTypeId = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_categoryValue = -1; /* INTEGER */ +static int hf_z3950_value = -1; /* INTEGER */ +static int hf_z3950_unitUsed = -1; /* Unit */ +static int hf_z3950_unitSystem = -1; /* InternationalString */ +static int hf_z3950_unitType = -1; /* StringOrNumeric */ +static int hf_z3950_unit = -1; /* StringOrNumeric */ +static int hf_z3950_scaleFactor = -1; /* INTEGER */ +static int hf_z3950_string = -1; /* InternationalString */ +static int hf_z3950_motd = -1; /* VisibleString */ +static int hf_z3950_dblist = -1; /* SEQUENCE_OF_DBName */ +static int hf_z3950_dblist_item = -1; /* DBName */ +static int hf_z3950_failReason = -1; /* BOOLEAN */ +static int hf_z3950_oCLC_UserInformation_text = -1; /* VisibleString */ +static int hf_z3950_bibliographicRecord = -1; /* EXTERNAL */ +static int hf_z3950_holdingsData = -1; /* SEQUENCE_OF_HoldingsRecord */ +static int hf_z3950_holdingsData_item = -1; /* HoldingsRecord */ +static int hf_z3950_marcHoldingsRecord = -1; /* EXTERNAL */ +static int hf_z3950_holdingsAndCirc = -1; /* HoldingsAndCircData */ +static int hf_z3950_typeOfRecord = -1; /* InternationalString */ +static int hf_z3950_encodingLevel = -1; /* InternationalString */ +static int hf_z3950_format = -1; /* InternationalString */ +static int hf_z3950_receiptAcqStatus = -1; /* InternationalString */ +static int hf_z3950_generalRetention = -1; /* InternationalString */ +static int hf_z3950_completeness = -1; /* InternationalString */ +static int hf_z3950_dateOfReport = -1; /* InternationalString */ +static int hf_z3950_nucCode = -1; /* InternationalString */ +static int hf_z3950_localLocation = -1; /* InternationalString */ +static int hf_z3950_shelvingLocation = -1; /* InternationalString */ +static int hf_z3950_callNumber = -1; /* InternationalString */ +static int hf_z3950_shelvingData = -1; /* InternationalString */ +static int hf_z3950_copyNumber = -1; /* InternationalString */ +static int hf_z3950_publicNote = -1; /* InternationalString */ +static int hf_z3950_reproductionNote = -1; /* InternationalString */ +static int hf_z3950_termsUseRepro = -1; /* InternationalString */ +static int hf_z3950_enumAndChron = -1; /* InternationalString */ +static int hf_z3950_volumes = -1; /* SEQUENCE_OF_Volume */ +static int hf_z3950_volumes_item = -1; /* Volume */ +static int hf_z3950_circulationData = -1; /* SEQUENCE_OF_CircRecord */ +static int hf_z3950_circulationData_item = -1; /* CircRecord */ +static int hf_z3950_enumeration = -1; /* InternationalString */ +static int hf_z3950_chronology = -1; /* InternationalString */ +static int hf_z3950_availableNow = -1; /* BOOLEAN */ +static int hf_z3950_availablityDate = -1; /* InternationalString */ +static int hf_z3950_availableThru = -1; /* InternationalString */ +static int hf_z3950_circRecord_restrictions = -1; /* InternationalString */ +static int hf_z3950_itemId = -1; /* InternationalString */ +static int hf_z3950_renewable = -1; /* BOOLEAN */ +static int hf_z3950_onHold = -1; /* BOOLEAN */ +static int hf_z3950_midspine = -1; /* InternationalString */ +static int hf_z3950_temporaryLocation = -1; /* InternationalString */ +static int hf_z3950_DiagnosticFormat_item = -1; /* DiagnosticFormat_item */ +static int hf_z3950_diagnosticFormat_item_diagnostic = -1; /* T_diagnosticFormat_item_diagnostic */ +static int hf_z3950_defaultDiagRec = -1; /* DefaultDiagFormat */ +static int hf_z3950_explicitDiagnostic = -1; /* DiagFormat */ +static int hf_z3950_message = -1; /* InternationalString */ +static int hf_z3950_tooMany = -1; /* T_tooMany */ +static int hf_z3950_tooManyWhat = -1; /* T_tooManyWhat */ +static int hf_z3950_max = -1; /* INTEGER */ +static int hf_z3950_badSpec = -1; /* T_badSpec */ +static int hf_z3950_goodOnes = -1; /* SEQUENCE_OF_Specification */ +static int hf_z3950_goodOnes_item = -1; /* Specification */ +static int hf_z3950_dbUnavail = -1; /* T_dbUnavail */ +static int hf_z3950_why = -1; /* T_why */ +static int hf_z3950_reasonCode = -1; /* T_reasonCode */ +static int hf_z3950_unSupOp = -1; /* T_unSupOp */ +static int hf_z3950_attribute = -1; /* T_attribute */ +static int hf_z3950_id = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_type = -1; /* INTEGER */ +static int hf_z3950_attCombo = -1; /* T_attCombo */ +static int hf_z3950_unsupportedCombination = -1; /* AttributeList */ +static int hf_z3950_recommendedAlternatives = -1; /* SEQUENCE_OF_AttributeList */ +static int hf_z3950_recommendedAlternatives_item = -1; /* AttributeList */ +static int hf_z3950_diagFormat_term = -1; /* T_diagFormat_term */ +static int hf_z3950_problem = -1; /* T_problem */ +static int hf_z3950_diagFormat_proximity = -1; /* T_diagFormat_proximity */ +static int hf_z3950_resultSets = -1; /* NULL */ +static int hf_z3950_badSet = -1; /* InternationalString */ +static int hf_z3950_relation = -1; /* INTEGER */ +static int hf_z3950_diagFormat_proximity_unit = -1; /* INTEGER */ +static int hf_z3950_diagFormat_proximity_ordered = -1; /* NULL */ +static int hf_z3950_diagFormat_proximity_exclusion = -1; /* NULL */ +static int hf_z3950_scan = -1; /* T_scan */ +static int hf_z3950_nonZeroStepSize = -1; /* NULL */ +static int hf_z3950_specifiedStepSize = -1; /* NULL */ +static int hf_z3950_termList1 = -1; /* NULL */ +static int hf_z3950_termList2 = -1; /* SEQUENCE_OF_AttributeList */ +static int hf_z3950_termList2_item = -1; /* AttributeList */ +static int hf_z3950_posInResponse = -1; /* T_posInResponse */ +static int hf_z3950_resources = -1; /* NULL */ +static int hf_z3950_endOfList = -1; /* NULL */ +static int hf_z3950_sort = -1; /* T_sort */ +static int hf_z3950_sequence = -1; /* NULL */ +static int hf_z3950_noRsName = -1; /* NULL */ +static int hf_z3950_diagFormat_sort_tooMany = -1; /* INTEGER */ +static int hf_z3950_incompatible = -1; /* NULL */ +static int hf_z3950_generic = -1; /* NULL */ +static int hf_z3950_diagFormat_sort_dbSpecific = -1; /* NULL */ +static int hf_z3950_key = -1; /* T_key */ +static int hf_z3950_action = -1; /* NULL */ +static int hf_z3950_illegal = -1; /* T_illegal */ +static int hf_z3950_inputTooLarge = -1; /* SEQUENCE_OF_InternationalString */ +static int hf_z3950_inputTooLarge_item = -1; /* InternationalString */ +static int hf_z3950_aggregateTooLarge = -1; /* NULL */ +static int hf_z3950_segmentation = -1; /* T_segmentation */ +static int hf_z3950_segmentCount = -1; /* NULL */ +static int hf_z3950_segmentSize = -1; /* INTEGER */ +static int hf_z3950_extServices = -1; /* T_extServices */ +static int hf_z3950_req = -1; /* T_req */ +static int hf_z3950_permission = -1; /* T_permission */ +static int hf_z3950_immediate = -1; /* T_immediate */ +static int hf_z3950_accessCtrl = -1; /* T_accessCtrl */ +static int hf_z3950_noUser = -1; /* NULL */ +static int hf_z3950_refused = -1; /* NULL */ +static int hf_z3950_diagFormat_accessCtrl_simple = -1; /* NULL */ +static int hf_z3950_diagFormat_accessCtrl_oid = -1; /* T_diagFormat_accessCtrl_oid */ +static int hf_z3950_diagFormat_accessCtrl_oid_item = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_alternative = -1; /* T_alternative */ +static int hf_z3950_alternative_item = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_pwdInv = -1; /* NULL */ +static int hf_z3950_pwdExp = -1; /* NULL */ +static int hf_z3950_diagFormat_recordSyntax = -1; /* T_diagFormat_recordSyntax */ +static int hf_z3950_unsupportedSyntax = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_suggestedAlternatives = -1; /* T_suggestedAlternatives */ +static int hf_z3950_suggestedAlternatives_item = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_targetInfo = -1; /* TargetInfo */ +static int hf_z3950_databaseInfo = -1; /* DatabaseInfo */ +static int hf_z3950_schemaInfo = -1; /* SchemaInfo */ +static int hf_z3950_tagSetInfo = -1; /* TagSetInfo */ +static int hf_z3950_recordSyntaxInfo = -1; /* RecordSyntaxInfo */ +static int hf_z3950_attributeSetInfo = -1; /* AttributeSetInfo */ +static int hf_z3950_termListInfo = -1; /* TermListInfo */ +static int hf_z3950_extendedServicesInfo = -1; /* ExtendedServicesInfo */ +static int hf_z3950_attributeDetails = -1; /* AttributeDetails */ +static int hf_z3950_termListDetails = -1; /* TermListDetails */ +static int hf_z3950_elementSetDetails = -1; /* ElementSetDetails */ +static int hf_z3950_retrievalRecordDetails = -1; /* RetrievalRecordDetails */ +static int hf_z3950_sortDetails = -1; /* SortDetails */ +static int hf_z3950_processing = -1; /* ProcessingInformation */ +static int hf_z3950_variants = -1; /* VariantSetInfo */ +static int hf_z3950_units = -1; /* UnitInfo */ +static int hf_z3950_categoryList = -1; /* CategoryList */ +static int hf_z3950_commonInfo = -1; /* CommonInfo */ +static int hf_z3950_name = -1; /* InternationalString */ +static int hf_z3950_recent_news = -1; /* HumanString */ +static int hf_z3950_icon = -1; /* IconObject */ +static int hf_z3950_namedResultSets = -1; /* BOOLEAN */ +static int hf_z3950_multipleDBsearch = -1; /* BOOLEAN */ +static int hf_z3950_maxResultSets = -1; /* INTEGER */ +static int hf_z3950_maxResultSize = -1; /* INTEGER */ +static int hf_z3950_maxTerms = -1; /* INTEGER */ +static int hf_z3950_timeoutInterval = -1; /* IntUnit */ +static int hf_z3950_welcomeMessage = -1; /* HumanString */ +static int hf_z3950_contactInfo = -1; /* ContactInfo */ +static int hf_z3950_description = -1; /* HumanString */ +static int hf_z3950_nicknames = -1; /* SEQUENCE_OF_InternationalString */ +static int hf_z3950_nicknames_item = -1; /* InternationalString */ +static int hf_z3950_usage_restrictions = -1; /* HumanString */ +static int hf_z3950_paymentAddr = -1; /* HumanString */ +static int hf_z3950_hours = -1; /* HumanString */ +static int hf_z3950_dbCombinations = -1; /* SEQUENCE_OF_DatabaseList */ +static int hf_z3950_dbCombinations_item = -1; /* DatabaseList */ +static int hf_z3950_addresses = -1; /* SEQUENCE_OF_NetworkAddress */ +static int hf_z3950_addresses_item = -1; /* NetworkAddress */ +static int hf_z3950_languages = -1; /* SEQUENCE_OF_InternationalString */ +static int hf_z3950_languages_item = -1; /* InternationalString */ +static int hf_z3950_commonAccessInfo = -1; /* AccessInfo */ +static int hf_z3950_databaseInfo_name = -1; /* DatabaseName */ +static int hf_z3950_explainDatabase = -1; /* NULL */ +static int hf_z3950_databaseInfo_nicknames = -1; /* SEQUENCE_OF_DatabaseName */ +static int hf_z3950_databaseInfo_nicknames_item = -1; /* DatabaseName */ +static int hf_z3950_user_fee = -1; /* BOOLEAN */ +static int hf_z3950_available = -1; /* BOOLEAN */ +static int hf_z3950_titleString = -1; /* HumanString */ +static int hf_z3950_keywords = -1; /* SEQUENCE_OF_HumanString */ +static int hf_z3950_keywords_item = -1; /* HumanString */ +static int hf_z3950_associatedDbs = -1; /* DatabaseList */ +static int hf_z3950_subDbs = -1; /* DatabaseList */ +static int hf_z3950_disclaimers = -1; /* HumanString */ +static int hf_z3950_news = -1; /* HumanString */ +static int hf_z3950_recordCount = -1; /* T_recordCount */ +static int hf_z3950_actualNumber = -1; /* INTEGER */ +static int hf_z3950_approxNumber = -1; /* INTEGER */ +static int hf_z3950_defaultOrder = -1; /* HumanString */ +static int hf_z3950_avRecordSize = -1; /* INTEGER */ +static int hf_z3950_bestTime = -1; /* HumanString */ +static int hf_z3950_lastUpdate = -1; /* GeneralizedTime */ +static int hf_z3950_updateInterval = -1; /* IntUnit */ +static int hf_z3950_coverage = -1; /* HumanString */ +static int hf_z3950_proprietary = -1; /* BOOLEAN */ +static int hf_z3950_copyrightText = -1; /* HumanString */ +static int hf_z3950_copyrightNotice = -1; /* HumanString */ +static int hf_z3950_producerContactInfo = -1; /* ContactInfo */ +static int hf_z3950_supplierContactInfo = -1; /* ContactInfo */ +static int hf_z3950_submissionContactInfo = -1; /* ContactInfo */ +static int hf_z3950_accessInfo = -1; /* AccessInfo */ +static int hf_z3950_tagTypeMapping = -1; /* T_tagTypeMapping */ +static int hf_z3950_tagTypeMapping_item = -1; /* T_tagTypeMapping_item */ +static int hf_z3950_tagType = -1; /* INTEGER */ +static int hf_z3950_tagSet = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_defaultTagType = -1; /* NULL */ +static int hf_z3950_recordStructure = -1; /* SEQUENCE_OF_ElementInfo */ +static int hf_z3950_recordStructure_item = -1; /* ElementInfo */ +static int hf_z3950_elementName = -1; /* InternationalString */ +static int hf_z3950_elementTagPath = -1; /* Path */ +static int hf_z3950_elementInfo_dataType = -1; /* ElementDataType */ +static int hf_z3950_required = -1; /* BOOLEAN */ +static int hf_z3950_repeatable = -1; /* BOOLEAN */ +static int hf_z3950_Path_item = -1; /* Path_item */ +static int hf_z3950_tagValue = -1; /* StringOrNumeric */ +static int hf_z3950_primitive = -1; /* PrimitiveDataType */ +static int hf_z3950_structured = -1; /* SEQUENCE_OF_ElementInfo */ +static int hf_z3950_structured_item = -1; /* ElementInfo */ +static int hf_z3950_tagSetInfo_elements = -1; /* T_tagSetInfo_elements */ +static int hf_z3950_tagSetInfo_elements_item = -1; /* T_tagSetInfo_elements_item */ +static int hf_z3950_elementname = -1; /* InternationalString */ +static int hf_z3950_elementTag = -1; /* StringOrNumeric */ +static int hf_z3950_dataType = -1; /* PrimitiveDataType */ +static int hf_z3950_otherTagInfo = -1; /* OtherInformation */ +static int hf_z3950_recordSyntax = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_transferSyntaxes = -1; /* T_transferSyntaxes */ +static int hf_z3950_transferSyntaxes_item = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_asn1Module = -1; /* InternationalString */ +static int hf_z3950_abstractStructure = -1; /* SEQUENCE_OF_ElementInfo */ +static int hf_z3950_abstractStructure_item = -1; /* ElementInfo */ +static int hf_z3950_attributeSetInfo_attributes = -1; /* SEQUENCE_OF_AttributeType */ +static int hf_z3950_attributeSetInfo_attributes_item = -1; /* AttributeType */ +static int hf_z3950_attributeType = -1; /* INTEGER */ +static int hf_z3950_attributeValues = -1; /* SEQUENCE_OF_AttributeDescription */ +static int hf_z3950_attributeValues_item = -1; /* AttributeDescription */ +static int hf_z3950_attributeDescription_attributeValue = -1; /* StringOrNumeric */ +static int hf_z3950_equivalentAttributes = -1; /* SEQUENCE_OF_StringOrNumeric */ +static int hf_z3950_equivalentAttributes_item = -1; /* StringOrNumeric */ +static int hf_z3950_termLists = -1; /* T_termLists */ +static int hf_z3950_termLists_item = -1; /* T_termLists_item */ +static int hf_z3950_title = -1; /* HumanString */ +static int hf_z3950_searchCost = -1; /* T_searchCost */ +static int hf_z3950_scanable = -1; /* BOOLEAN */ +static int hf_z3950_broader = -1; /* SEQUENCE_OF_InternationalString */ +static int hf_z3950_broader_item = -1; /* InternationalString */ +static int hf_z3950_narrower = -1; /* SEQUENCE_OF_InternationalString */ +static int hf_z3950_narrower_item = -1; /* InternationalString */ +static int hf_z3950_extendedServicesInfo_type = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_privateType = -1; /* BOOLEAN */ +static int hf_z3950_restrictionsApply = -1; /* BOOLEAN */ +static int hf_z3950_feeApply = -1; /* BOOLEAN */ +static int hf_z3950_retentionSupported = -1; /* BOOLEAN */ +static int hf_z3950_extendedServicesInfo_waitAction = -1; /* T_extendedServicesInfo_waitAction */ +static int hf_z3950_specificExplain = -1; /* EXTERNAL */ +static int hf_z3950_esASN = -1; /* InternationalString */ +static int hf_z3950_attributesBySet = -1; /* SEQUENCE_OF_AttributeSetDetails */ +static int hf_z3950_attributesBySet_item = -1; /* AttributeSetDetails */ +static int hf_z3950_attributeCombinations = -1; /* AttributeCombinations */ +static int hf_z3950_attributesByType = -1; /* SEQUENCE_OF_AttributeTypeDetails */ +static int hf_z3950_attributesByType_item = -1; /* AttributeTypeDetails */ +static int hf_z3950_defaultIfOmitted = -1; /* OmittedAttributeInterpretation */ +static int hf_z3950_attributeTypeDetails_attributeValues = -1; /* SEQUENCE_OF_AttributeValue */ +static int hf_z3950_attributeTypeDetails_attributeValues_item = -1; /* AttributeValue */ +static int hf_z3950_defaultValue = -1; /* StringOrNumeric */ +static int hf_z3950_defaultDescription = -1; /* HumanString */ +static int hf_z3950_attributeValue_value = -1; /* StringOrNumeric */ +static int hf_z3950_subAttributes = -1; /* SEQUENCE_OF_StringOrNumeric */ +static int hf_z3950_subAttributes_item = -1; /* StringOrNumeric */ +static int hf_z3950_superAttributes = -1; /* SEQUENCE_OF_StringOrNumeric */ +static int hf_z3950_superAttributes_item = -1; /* StringOrNumeric */ +static int hf_z3950_partialSupport = -1; /* NULL */ +static int hf_z3950_termListName = -1; /* InternationalString */ +static int hf_z3950_termListDetails_attributes = -1; /* AttributeCombinations */ +static int hf_z3950_scanInfo = -1; /* T_scanInfo */ +static int hf_z3950_maxStepSize = -1; /* INTEGER */ +static int hf_z3950_collatingSequence = -1; /* HumanString */ +static int hf_z3950_increasing = -1; /* BOOLEAN */ +static int hf_z3950_estNumberTerms = -1; /* INTEGER */ +static int hf_z3950_sampleTerms = -1; /* SEQUENCE_OF_Term */ +static int hf_z3950_sampleTerms_item = -1; /* Term */ +static int hf_z3950_elementSetDetails_elementSetName = -1; /* ElementSetName */ +static int hf_z3950_detailsPerElement = -1; /* SEQUENCE_OF_PerElementDetails */ +static int hf_z3950_detailsPerElement_item = -1; /* PerElementDetails */ +static int hf_z3950_recordTag = -1; /* RecordTag */ +static int hf_z3950_schemaTags = -1; /* SEQUENCE_OF_Path */ +static int hf_z3950_schemaTags_item = -1; /* Path */ +static int hf_z3950_maxSize = -1; /* INTEGER */ +static int hf_z3950_minSize = -1; /* INTEGER */ +static int hf_z3950_avgSize = -1; /* INTEGER */ +static int hf_z3950_fixedSize = -1; /* INTEGER */ +static int hf_z3950_contents = -1; /* HumanString */ +static int hf_z3950_billingInfo = -1; /* HumanString */ +static int hf_z3950_restrictions = -1; /* HumanString */ +static int hf_z3950_alternateNames = -1; /* SEQUENCE_OF_InternationalString */ +static int hf_z3950_alternateNames_item = -1; /* InternationalString */ +static int hf_z3950_genericNames = -1; /* SEQUENCE_OF_InternationalString */ +static int hf_z3950_genericNames_item = -1; /* InternationalString */ +static int hf_z3950_searchAccess = -1; /* AttributeCombinations */ +static int hf_z3950_qualifier = -1; /* StringOrNumeric */ +static int hf_z3950_sortKeys = -1; /* SEQUENCE_OF_SortKeyDetails */ +static int hf_z3950_sortKeys_item = -1; /* SortKeyDetails */ +static int hf_z3950_elementSpecifications = -1; /* SEQUENCE_OF_Specification */ +static int hf_z3950_elementSpecifications_item = -1; /* Specification */ +static int hf_z3950_attributeSpecifications = -1; /* AttributeCombinations */ +static int hf_z3950_sortType = -1; /* T_sortType */ +static int hf_z3950_character = -1; /* NULL */ +static int hf_z3950_sortKeyDetails_sortType_numeric = -1; /* NULL */ +static int hf_z3950_sortKeyDetails_sortType_structured = -1; /* HumanString */ +static int hf_z3950_sortKeyDetails_caseSensitivity = -1; /* T_sortKeyDetails_caseSensitivity */ +static int hf_z3950_processingContext = -1; /* T_processingContext */ +static int hf_z3950_instructions = -1; /* EXTERNAL */ +static int hf_z3950_variantSet = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_variantSetInfo_variants = -1; /* SEQUENCE_OF_VariantClass */ +static int hf_z3950_variantSetInfo_variants_item = -1; /* VariantClass */ +static int hf_z3950_variantClass = -1; /* INTEGER */ +static int hf_z3950_variantTypes = -1; /* SEQUENCE_OF_VariantType */ +static int hf_z3950_variantTypes_item = -1; /* VariantType */ +static int hf_z3950_variantType = -1; /* INTEGER */ +static int hf_z3950_variantValue = -1; /* VariantValue */ +static int hf_z3950_values = -1; /* ValueSet */ +static int hf_z3950_range = -1; /* ValueRange */ +static int hf_z3950_enumerated = -1; /* SEQUENCE_OF_ValueDescription */ +static int hf_z3950_enumerated_item = -1; /* ValueDescription */ +static int hf_z3950_lower = -1; /* ValueDescription */ +static int hf_z3950_upper = -1; /* ValueDescription */ +static int hf_z3950_integer = -1; /* INTEGER */ +static int hf_z3950_octets = -1; /* OCTET_STRING */ +static int hf_z3950_valueDescription_unit = -1; /* Unit */ +static int hf_z3950_valueAndUnit = -1; /* IntUnit */ +static int hf_z3950_unitInfo_units = -1; /* SEQUENCE_OF_UnitType */ +static int hf_z3950_unitInfo_units_item = -1; /* UnitType */ +static int hf_z3950_unitType_units = -1; /* SEQUENCE_OF_Units */ +static int hf_z3950_unitType_units_item = -1; /* Units */ +static int hf_z3950_categories = -1; /* SEQUENCE_OF_CategoryInfo */ +static int hf_z3950_categories_item = -1; /* CategoryInfo */ +static int hf_z3950_categoryInfo_category = -1; /* InternationalString */ +static int hf_z3950_originalCategory = -1; /* InternationalString */ +static int hf_z3950_dateAdded = -1; /* GeneralizedTime */ +static int hf_z3950_dateChanged = -1; /* GeneralizedTime */ +static int hf_z3950_expiry = -1; /* GeneralizedTime */ +static int hf_z3950_humanString_Language = -1; /* LanguageCode */ +static int hf_z3950_HumanString_item = -1; /* HumanString_item */ +static int hf_z3950_language = -1; /* LanguageCode */ +static int hf_z3950_text = -1; /* InternationalString */ +static int hf_z3950_IconObject_item = -1; /* IconObject_item */ +static int hf_z3950_bodyType = -1; /* T_bodyType */ +static int hf_z3950_ianaType = -1; /* InternationalString */ +static int hf_z3950_z3950type = -1; /* InternationalString */ +static int hf_z3950_otherType = -1; /* InternationalString */ +static int hf_z3950_content = -1; /* OCTET_STRING */ +static int hf_z3950_address = -1; /* HumanString */ +static int hf_z3950_email = -1; /* InternationalString */ +static int hf_z3950_phone = -1; /* InternationalString */ +static int hf_z3950_internetAddress = -1; /* T_internetAddress */ +static int hf_z3950_hostAddress = -1; /* InternationalString */ +static int hf_z3950_port = -1; /* INTEGER */ +static int hf_z3950_osiPresentationAddress = -1; /* T_osiPresentationAddress */ +static int hf_z3950_pSel = -1; /* InternationalString */ +static int hf_z3950_sSel = -1; /* InternationalString */ +static int hf_z3950_tSel = -1; /* InternationalString */ +static int hf_z3950_nSap = -1; /* InternationalString */ +static int hf_z3950_networkAddress_other = -1; /* T_networkAddress_other */ +static int hf_z3950_networkAddress_other_type = -1; /* InternationalString */ +static int hf_z3950_networkAddress_other_address = -1; /* InternationalString */ +static int hf_z3950_queryTypesSupported = -1; /* SEQUENCE_OF_QueryTypeDetails */ +static int hf_z3950_queryTypesSupported_item = -1; /* QueryTypeDetails */ +static int hf_z3950_diagnosticsSets = -1; /* T_diagnosticsSets */ +static int hf_z3950_diagnosticsSets_item = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_attributeSetIds = -1; /* SEQUENCE_OF_AttributeSetId */ +static int hf_z3950_attributeSetIds_item = -1; /* AttributeSetId */ +static int hf_z3950_schemas = -1; /* T_schemas */ +static int hf_z3950_schemas_item = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_recordSyntaxes = -1; /* T_recordSyntaxes */ +static int hf_z3950_recordSyntaxes_item = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_resourceChallenges = -1; /* T_resourceChallenges */ +static int hf_z3950_resourceChallenges_item = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_restrictedAccess = -1; /* AccessRestrictions */ +static int hf_z3950_costInfo = -1; /* Costs */ +static int hf_z3950_variantSets = -1; /* T_variantSets */ +static int hf_z3950_variantSets_item = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_elementSetNames = -1; /* SEQUENCE_OF_ElementSetName */ +static int hf_z3950_elementSetNames_item = -1; /* ElementSetName */ +static int hf_z3950_unitSystems = -1; /* SEQUENCE_OF_InternationalString */ +static int hf_z3950_unitSystems_item = -1; /* InternationalString */ +static int hf_z3950_queryTypeDetails_private = -1; /* PrivateCapabilities */ +static int hf_z3950_queryTypeDetails_rpn = -1; /* RpnCapabilities */ +static int hf_z3950_iso8777 = -1; /* Iso8777Capabilities */ +static int hf_z3950_z39_58 = -1; /* HumanString */ +static int hf_z3950_erpn = -1; /* RpnCapabilities */ +static int hf_z3950_rankedList = -1; /* HumanString */ +static int hf_z3950_privateCapabilities_operators = -1; /* T_privateCapabilities_operators */ +static int hf_z3950_privateCapabilities_operators_item = -1; /* T_privateCapabilities_operators_item */ +static int hf_z3950_operator = -1; /* InternationalString */ +static int hf_z3950_searchKeys = -1; /* SEQUENCE_OF_SearchKey */ +static int hf_z3950_searchKeys_item = -1; /* SearchKey */ +static int hf_z3950_privateCapabilities_description = -1; /* SEQUENCE_OF_HumanString */ +static int hf_z3950_privateCapabilities_description_item = -1; /* HumanString */ +static int hf_z3950_operators = -1; /* T_operators */ +static int hf_z3950_operators_item = -1; /* INTEGER */ +static int hf_z3950_resultSetAsOperandSupported = -1; /* BOOLEAN */ +static int hf_z3950_restrictionOperandSupported = -1; /* BOOLEAN */ +static int hf_z3950_proximity = -1; /* ProximitySupport */ +static int hf_z3950_anySupport = -1; /* BOOLEAN */ +static int hf_z3950_unitsSupported = -1; /* T_unitsSupported */ +static int hf_z3950_unitsSupported_item = -1; /* T_unitsSupported_item */ +static int hf_z3950_proximitySupport_unitsSupported_item_known = -1; /* INTEGER */ +static int hf_z3950_proximitySupport_unitsSupported_item_private = -1; /* T_proximitySupport_unitsSupported_item_private */ +static int hf_z3950_proximitySupport_unitsSupported_item_private_unit = -1; /* INTEGER */ +static int hf_z3950_searchKey = -1; /* InternationalString */ +static int hf_z3950_AccessRestrictions_item = -1; /* AccessRestrictions_item */ +static int hf_z3950_accessType = -1; /* T_accessType */ +static int hf_z3950_accessText = -1; /* HumanString */ +static int hf_z3950_accessChallenges = -1; /* T_accessChallenges */ +static int hf_z3950_accessChallenges_item = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_connectCharge = -1; /* Charge */ +static int hf_z3950_connectTime = -1; /* Charge */ +static int hf_z3950_displayCharge = -1; /* Charge */ +static int hf_z3950_searchCharge = -1; /* Charge */ +static int hf_z3950_subscriptCharge = -1; /* Charge */ +static int hf_z3950_otherCharges = -1; /* T_otherCharges */ +static int hf_z3950_otherCharges_item = -1; /* T_otherCharges_item */ +static int hf_z3950_forWhat = -1; /* HumanString */ +static int hf_z3950_charge = -1; /* Charge */ +static int hf_z3950_cost = -1; /* IntUnit */ +static int hf_z3950_perWhat = -1; /* Unit */ +static int hf_z3950_charge_text = -1; /* HumanString */ +static int hf_z3950_DatabaseList_item = -1; /* DatabaseName */ +static int hf_z3950_defaultAttributeSet = -1; /* AttributeSetId */ +static int hf_z3950_legalCombinations = -1; /* SEQUENCE_OF_AttributeCombination */ +static int hf_z3950_legalCombinations_item = -1; /* AttributeCombination */ +static int hf_z3950_AttributeCombination_item = -1; /* AttributeOccurrence */ +static int hf_z3950_mustBeSupplied = -1; /* NULL */ +static int hf_z3950_attributeOccurrence_attributeValues = -1; /* T_attributeOccurrence_attributeValues */ +static int hf_z3950_any_or_none = -1; /* NULL */ +static int hf_z3950_specific = -1; /* SEQUENCE_OF_StringOrNumeric */ +static int hf_z3950_specific_item = -1; /* StringOrNumeric */ +static int hf_z3950_briefBib_title = -1; /* InternationalString */ +static int hf_z3950_author = -1; /* InternationalString */ +static int hf_z3950_recordType = -1; /* InternationalString */ +static int hf_z3950_bibliographicLevel = -1; /* InternationalString */ +static int hf_z3950_briefBib_format = -1; /* SEQUENCE_OF_FormatSpec */ +static int hf_z3950_briefBib_format_item = -1; /* FormatSpec */ +static int hf_z3950_publicationPlace = -1; /* InternationalString */ +static int hf_z3950_publicationDate = -1; /* InternationalString */ +static int hf_z3950_targetSystemKey = -1; /* InternationalString */ +static int hf_z3950_satisfyingElement = -1; /* InternationalString */ +static int hf_z3950_rank = -1; /* INTEGER */ +static int hf_z3950_documentId = -1; /* InternationalString */ +static int hf_z3950_abstract = -1; /* InternationalString */ +static int hf_z3950_formatSpec_type = -1; /* InternationalString */ +static int hf_z3950_size = -1; /* INTEGER */ +static int hf_z3950_bestPosn = -1; /* INTEGER */ +static int hf_z3950_GenericRecord_item = -1; /* TaggedElement */ +static int hf_z3950_tagOccurrence = -1; /* INTEGER */ +static int hf_z3950_taggedElement_content = -1; /* ElementData */ +static int hf_z3950_metaData = -1; /* ElementMetaData */ +static int hf_z3950_appliedVariant = -1; /* Variant */ +static int hf_z3950_date = -1; /* GeneralizedTime */ +static int hf_z3950_ext = -1; /* EXTERNAL */ +static int hf_z3950_trueOrFalse = -1; /* BOOLEAN */ +static int hf_z3950_intUnit = -1; /* IntUnit */ +static int hf_z3950_elementNotThere = -1; /* NULL */ +static int hf_z3950_elementEmpty = -1; /* NULL */ +static int hf_z3950_noDataRequested = -1; /* NULL */ +static int hf_z3950_elementData_diagnostic = -1; /* EXTERNAL */ +static int hf_z3950_subtree = -1; /* SEQUENCE_OF_TaggedElement */ +static int hf_z3950_subtree_item = -1; /* TaggedElement */ +static int hf_z3950_seriesOrder = -1; /* Order */ +static int hf_z3950_usageRight = -1; /* Usage */ +static int hf_z3950_hits = -1; /* SEQUENCE_OF_HitVector */ +static int hf_z3950_hits_item = -1; /* HitVector */ +static int hf_z3950_displayName = -1; /* InternationalString */ +static int hf_z3950_supportedVariants = -1; /* SEQUENCE_OF_Variant */ +static int hf_z3950_supportedVariants_item = -1; /* Variant */ +static int hf_z3950_elementDescriptor = -1; /* OCTET_STRING */ +static int hf_z3950_surrogateFor = -1; /* TagPath */ +static int hf_z3950_surrogateElement = -1; /* TagPath */ +static int hf_z3950_TagPath_item = -1; /* TagPath_item */ +static int hf_z3950_ascending = -1; /* BOOLEAN */ +static int hf_z3950_order = -1; /* INTEGER */ +static int hf_z3950_usage_type = -1; /* T_usage_type */ +static int hf_z3950_restriction = -1; /* InternationalString */ +static int hf_z3950_satisfier = -1; /* Term */ +static int hf_z3950_offsetIntoElement = -1; /* IntUnit */ +static int hf_z3950_length = -1; /* IntUnit */ +static int hf_z3950_hitRank = -1; /* INTEGER */ +static int hf_z3950_targetToken = -1; /* OCTET_STRING */ +static int hf_z3950_globalVariantSetId = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_triples = -1; /* T_triples */ +static int hf_z3950_triples_item = -1; /* T_triples_item */ +static int hf_z3950_variantSetId = -1; /* OBJECT_IDENTIFIER */ +static int hf_z3950_class = -1; /* INTEGER */ +static int hf_z3950_variant_triples_item_value = -1; /* T_variant_triples_item_value */ +static int hf_z3950_octetString = -1; /* OCTET_STRING */ +static int hf_z3950_boolean = -1; /* BOOLEAN */ +static int hf_z3950_variant_triples_item_value_unit = -1; /* Unit */ +static int hf_z3950_taskPackage_description = -1; /* InternationalString */ +static int hf_z3950_targetReference = -1; /* OCTET_STRING */ +static int hf_z3950_creationDateTime = -1; /* GeneralizedTime */ +static int hf_z3950_taskStatus = -1; /* T_taskStatus */ +static int hf_z3950_packageDiagnostics = -1; /* SEQUENCE_OF_DiagRec */ +static int hf_z3950_packageDiagnostics_item = -1; /* DiagRec */ +static int hf_z3950_challenge = -1; /* Challenge */ +static int hf_z3950_response = -1; /* Response */ +static int hf_z3950_Challenge_item = -1; /* Challenge_item */ +static int hf_z3950_promptId = -1; /* PromptId */ +static int hf_z3950_defaultResponse = -1; /* InternationalString */ +static int hf_z3950_promptInfo = -1; /* T_promptInfo */ +static int hf_z3950_challenge_item_promptInfo_character = -1; /* InternationalString */ +static int hf_z3950_encrypted = -1; /* Encryption */ +static int hf_z3950_regExpr = -1; /* InternationalString */ +static int hf_z3950_responseRequired = -1; /* NULL */ +static int hf_z3950_allowedValues = -1; /* SEQUENCE_OF_InternationalString */ +static int hf_z3950_allowedValues_item = -1; /* InternationalString */ +static int hf_z3950_shouldSave = -1; /* NULL */ +static int hf_z3950_challenge_item_dataType = -1; /* T_challenge_item_dataType */ +static int hf_z3950_challenge_item_diagnostic = -1; /* EXTERNAL */ +static int hf_z3950_Response_item = -1; /* Response_item */ +static int hf_z3950_promptResponse = -1; /* T_promptResponse */ +static int hf_z3950_accept = -1; /* BOOLEAN */ +static int hf_z3950_acknowledge = -1; /* NULL */ +static int hf_z3950_enummeratedPrompt = -1; /* T_enummeratedPrompt */ +static int hf_z3950_promptId_enummeratedPrompt_type = -1; /* T_promptId_enummeratedPrompt_type */ +static int hf_z3950_suggestedString = -1; /* InternationalString */ +static int hf_z3950_nonEnumeratedPrompt = -1; /* InternationalString */ +static int hf_z3950_cryptType = -1; /* OCTET_STRING */ +static int hf_z3950_credential = -1; /* OCTET_STRING */ +static int hf_z3950_data = -1; /* OCTET_STRING */ +static int hf_z3950_dES_RN_Object_challenge = -1; /* DRNType */ +static int hf_z3950_rES_RN_Object_response = -1; /* DRNType */ +static int hf_z3950_dRNType_userId = -1; /* OCTET_STRING */ +static int hf_z3950_salt = -1; /* OCTET_STRING */ +static int hf_z3950_randomNumber = -1; /* OCTET_STRING */ +static int hf_z3950_kRBObject_challenge = -1; /* KRBRequest */ +static int hf_z3950_kRBObject_response = -1; /* KRBResponse */ +static int hf_z3950_service = -1; /* InternationalString */ +static int hf_z3950_instance = -1; /* InternationalString */ +static int hf_z3950_realm = -1; /* InternationalString */ +static int hf_z3950_userid = -1; /* InternationalString */ +static int hf_z3950_ticket = -1; /* OCTET_STRING */ +static int hf_z3950_SearchInfoReport_item = -1; /* SearchInfoReport_item */ +static int hf_z3950_subqueryId = -1; /* InternationalString */ +static int hf_z3950_fullQuery = -1; /* BOOLEAN */ +static int hf_z3950_subqueryExpression = -1; /* QueryExpression */ +static int hf_z3950_subqueryInterpretation = -1; /* QueryExpression */ +static int hf_z3950_subqueryRecommendation = -1; /* QueryExpression */ +static int hf_z3950_subqueryCount = -1; /* INTEGER */ +static int hf_z3950_subqueryWeight = -1; /* IntUnit */ +static int hf_z3950_resultsByDB = -1; /* ResultsByDB */ +static int hf_z3950_ResultsByDB_item = -1; /* ResultsByDB_item */ +static int hf_z3950_databases = -1; /* T_databases */ +static int hf_z3950_all = -1; /* NULL */ +static int hf_z3950_list = -1; /* SEQUENCE_OF_DatabaseName */ +static int hf_z3950_list_item = -1; /* DatabaseName */ +static int hf_z3950_count = -1; /* INTEGER */ +static int hf_z3950_queryExpression_term = -1; /* T_queryExpression_term */ +static int hf_z3950_queryTerm = -1; /* Term */ +static int hf_z3950_termComment = -1; /* InternationalString */ +/* named bits */ +static int hf_z3950_ProtocolVersion_U_version_1 = -1; +static int hf_z3950_ProtocolVersion_U_version_2 = -1; +static int hf_z3950_ProtocolVersion_U_version_3 = -1; +static int hf_z3950_Options_U_search = -1; +static int hf_z3950_Options_U_present = -1; +static int hf_z3950_Options_U_delSet = -1; +static int hf_z3950_Options_U_resourceReport = -1; +static int hf_z3950_Options_U_triggerResourceCtrl = -1; +static int hf_z3950_Options_U_resourceCtrl = -1; +static int hf_z3950_Options_U_accessCtrl = -1; +static int hf_z3950_Options_U_scan = -1; +static int hf_z3950_Options_U_sort = -1; +static int hf_z3950_Options_U_extendedServices = -1; +static int hf_z3950_Options_U_level_1Segmentation = -1; +static int hf_z3950_Options_U_level_2Segmentation = -1; +static int hf_z3950_Options_U_concurrentOperations = -1; +static int hf_z3950_Options_U_namedResultSets = -1; + +/*--- End of included file: packet-z3950-hf.c ---*/ +#line 659 "./asn1/z3950/packet-z3950-template.c" + +static int hf_z3950_referenceId_printable = -1; +static int hf_z3950_general_printable = -1; + +/* Initialize the subtree pointers */ +static int ett_z3950 = -1; + + +/*--- Included file: packet-z3950-ett.c ---*/ +#line 1 "./asn1/z3950/packet-z3950-ett.c" +static gint ett_z3950_PDU = -1; +static gint ett_z3950_InitializeRequest = -1; +static gint ett_z3950_T_idAuthentication = -1; +static gint ett_z3950_T_idPass = -1; +static gint ett_z3950_InitializeResponse = -1; +static gint ett_z3950_ProtocolVersion_U = -1; +static gint ett_z3950_Options_U = -1; +static gint ett_z3950_SearchRequest = -1; +static gint ett_z3950_SEQUENCE_OF_DatabaseName = -1; +static gint ett_z3950_Query = -1; +static gint ett_z3950_RPNQuery = -1; +static gint ett_z3950_RPNStructure = -1; +static gint ett_z3950_T_rpnRpnOp = -1; +static gint ett_z3950_Operand = -1; +static gint ett_z3950_AttributesPlusTerm_U = -1; +static gint ett_z3950_ResultSetPlusAttributes_U = -1; +static gint ett_z3950_SEQUENCE_OF_AttributeElement = -1; +static gint ett_z3950_Term = -1; +static gint ett_z3950_Operator_U = -1; +static gint ett_z3950_AttributeElement = -1; +static gint ett_z3950_T_attributeValue = -1; +static gint ett_z3950_T_attributeValue_complex = -1; +static gint ett_z3950_SEQUENCE_OF_StringOrNumeric = -1; +static gint ett_z3950_T_semanticAction = -1; +static gint ett_z3950_ProximityOperator = -1; +static gint ett_z3950_T_proximityUnitCode = -1; +static gint ett_z3950_SearchResponse = -1; +static gint ett_z3950_PresentRequest = -1; +static gint ett_z3950_SEQUENCE_OF_Range = -1; +static gint ett_z3950_T_recordComposition = -1; +static gint ett_z3950_Segment = -1; +static gint ett_z3950_SEQUENCE_OF_NamePlusRecord = -1; +static gint ett_z3950_PresentResponse = -1; +static gint ett_z3950_Records = -1; +static gint ett_z3950_SEQUENCE_OF_DiagRec = -1; +static gint ett_z3950_NamePlusRecord = -1; +static gint ett_z3950_T_record = -1; +static gint ett_z3950_FragmentSyntax = -1; +static gint ett_z3950_DiagRec = -1; +static gint ett_z3950_DefaultDiagFormat = -1; +static gint ett_z3950_T_addinfo = -1; +static gint ett_z3950_Range = -1; +static gint ett_z3950_ElementSetNames = -1; +static gint ett_z3950_T_databaseSpecific = -1; +static gint ett_z3950_T_databaseSpecific_item = -1; +static gint ett_z3950_CompSpec = -1; +static gint ett_z3950_T_dbSpecific = -1; +static gint ett_z3950_T_dbSpecific_item = -1; +static gint ett_z3950_T_compSpec_recordSyntax = -1; +static gint ett_z3950_Specification = -1; +static gint ett_z3950_T_specification_elementSpec = -1; +static gint ett_z3950_DeleteResultSetRequest = -1; +static gint ett_z3950_SEQUENCE_OF_ResultSetId = -1; +static gint ett_z3950_DeleteResultSetResponse = -1; +static gint ett_z3950_ListStatuses = -1; +static gint ett_z3950_ListStatuses_item = -1; +static gint ett_z3950_AccessControlRequest = -1; +static gint ett_z3950_T_securityChallenge = -1; +static gint ett_z3950_AccessControlResponse = -1; +static gint ett_z3950_T_securityChallengeResponse = -1; +static gint ett_z3950_ResourceControlRequest = -1; +static gint ett_z3950_ResourceControlResponse = -1; +static gint ett_z3950_TriggerResourceControlRequest = -1; +static gint ett_z3950_ResourceReportRequest = -1; +static gint ett_z3950_ResourceReportResponse = -1; +static gint ett_z3950_ScanRequest = -1; +static gint ett_z3950_ScanResponse = -1; +static gint ett_z3950_ListEntries = -1; +static gint ett_z3950_SEQUENCE_OF_Entry = -1; +static gint ett_z3950_Entry = -1; +static gint ett_z3950_TermInfo = -1; +static gint ett_z3950_SEQUENCE_OF_AttributesPlusTerm = -1; +static gint ett_z3950_OccurrenceByAttributes = -1; +static gint ett_z3950_OccurrenceByAttributes_item = -1; +static gint ett_z3950_T_occurrences = -1; +static gint ett_z3950_T_byDatabase = -1; +static gint ett_z3950_T_byDatabase_item = -1; +static gint ett_z3950_SortRequest = -1; +static gint ett_z3950_SEQUENCE_OF_InternationalString = -1; +static gint ett_z3950_SEQUENCE_OF_SortKeySpec = -1; +static gint ett_z3950_SortResponse = -1; +static gint ett_z3950_SortKeySpec = -1; +static gint ett_z3950_T_missingValueAction = -1; +static gint ett_z3950_SortElement = -1; +static gint ett_z3950_T_datbaseSpecific = -1; +static gint ett_z3950_T_datbaseSpecific_item = -1; +static gint ett_z3950_SortKey = -1; +static gint ett_z3950_T_sortAttributes = -1; +static gint ett_z3950_ExtendedServicesRequest = -1; +static gint ett_z3950_ExtendedServicesResponse = -1; +static gint ett_z3950_Permissions = -1; +static gint ett_z3950_Permissions_item = -1; +static gint ett_z3950_T_allowableFunctions = -1; +static gint ett_z3950_Close = -1; +static gint ett_z3950_OtherInformation_U = -1; +static gint ett_z3950_T__untag_item = -1; +static gint ett_z3950_T_information = -1; +static gint ett_z3950_InfoCategory = -1; +static gint ett_z3950_IntUnit = -1; +static gint ett_z3950_Unit = -1; +static gint ett_z3950_StringOrNumeric = -1; +static gint ett_z3950_OCLC_UserInformation = -1; +static gint ett_z3950_SEQUENCE_OF_DBName = -1; +static gint ett_z3950_OPACRecord = -1; +static gint ett_z3950_SEQUENCE_OF_HoldingsRecord = -1; +static gint ett_z3950_HoldingsRecord = -1; +static gint ett_z3950_HoldingsAndCircData = -1; +static gint ett_z3950_SEQUENCE_OF_Volume = -1; +static gint ett_z3950_SEQUENCE_OF_CircRecord = -1; +static gint ett_z3950_Volume = -1; +static gint ett_z3950_CircRecord = -1; +static gint ett_z3950_DiagnosticFormat = -1; +static gint ett_z3950_DiagnosticFormat_item = -1; +static gint ett_z3950_T_diagnosticFormat_item_diagnostic = -1; +static gint ett_z3950_DiagFormat = -1; +static gint ett_z3950_T_tooMany = -1; +static gint ett_z3950_T_badSpec = -1; +static gint ett_z3950_SEQUENCE_OF_Specification = -1; +static gint ett_z3950_T_dbUnavail = -1; +static gint ett_z3950_T_why = -1; +static gint ett_z3950_T_attribute = -1; +static gint ett_z3950_T_attCombo = -1; +static gint ett_z3950_SEQUENCE_OF_AttributeList = -1; +static gint ett_z3950_T_diagFormat_term = -1; +static gint ett_z3950_T_diagFormat_proximity = -1; +static gint ett_z3950_T_scan = -1; +static gint ett_z3950_T_sort = -1; +static gint ett_z3950_T_segmentation = -1; +static gint ett_z3950_T_extServices = -1; +static gint ett_z3950_T_accessCtrl = -1; +static gint ett_z3950_T_diagFormat_accessCtrl_oid = -1; +static gint ett_z3950_T_alternative = -1; +static gint ett_z3950_T_diagFormat_recordSyntax = -1; +static gint ett_z3950_T_suggestedAlternatives = -1; +static gint ett_z3950_Explain_Record = -1; +static gint ett_z3950_TargetInfo = -1; +static gint ett_z3950_SEQUENCE_OF_DatabaseList = -1; +static gint ett_z3950_SEQUENCE_OF_NetworkAddress = -1; +static gint ett_z3950_DatabaseInfo = -1; +static gint ett_z3950_SEQUENCE_OF_HumanString = -1; +static gint ett_z3950_T_recordCount = -1; +static gint ett_z3950_SchemaInfo = -1; +static gint ett_z3950_T_tagTypeMapping = -1; +static gint ett_z3950_T_tagTypeMapping_item = -1; +static gint ett_z3950_SEQUENCE_OF_ElementInfo = -1; +static gint ett_z3950_ElementInfo = -1; +static gint ett_z3950_Path = -1; +static gint ett_z3950_Path_item = -1; +static gint ett_z3950_ElementDataType = -1; +static gint ett_z3950_TagSetInfo = -1; +static gint ett_z3950_T_tagSetInfo_elements = -1; +static gint ett_z3950_T_tagSetInfo_elements_item = -1; +static gint ett_z3950_RecordSyntaxInfo = -1; +static gint ett_z3950_T_transferSyntaxes = -1; +static gint ett_z3950_AttributeSetInfo = -1; +static gint ett_z3950_SEQUENCE_OF_AttributeType = -1; +static gint ett_z3950_AttributeType = -1; +static gint ett_z3950_SEQUENCE_OF_AttributeDescription = -1; +static gint ett_z3950_AttributeDescription = -1; +static gint ett_z3950_TermListInfo = -1; +static gint ett_z3950_T_termLists = -1; +static gint ett_z3950_T_termLists_item = -1; +static gint ett_z3950_ExtendedServicesInfo = -1; +static gint ett_z3950_AttributeDetails = -1; +static gint ett_z3950_SEQUENCE_OF_AttributeSetDetails = -1; +static gint ett_z3950_AttributeSetDetails = -1; +static gint ett_z3950_SEQUENCE_OF_AttributeTypeDetails = -1; +static gint ett_z3950_AttributeTypeDetails = -1; +static gint ett_z3950_SEQUENCE_OF_AttributeValue = -1; +static gint ett_z3950_OmittedAttributeInterpretation = -1; +static gint ett_z3950_AttributeValue = -1; +static gint ett_z3950_TermListDetails = -1; +static gint ett_z3950_T_scanInfo = -1; +static gint ett_z3950_SEQUENCE_OF_Term = -1; +static gint ett_z3950_ElementSetDetails = -1; +static gint ett_z3950_SEQUENCE_OF_PerElementDetails = -1; +static gint ett_z3950_RetrievalRecordDetails = -1; +static gint ett_z3950_PerElementDetails = -1; +static gint ett_z3950_SEQUENCE_OF_Path = -1; +static gint ett_z3950_RecordTag = -1; +static gint ett_z3950_SortDetails = -1; +static gint ett_z3950_SEQUENCE_OF_SortKeyDetails = -1; +static gint ett_z3950_SortKeyDetails = -1; +static gint ett_z3950_T_sortType = -1; +static gint ett_z3950_ProcessingInformation = -1; +static gint ett_z3950_VariantSetInfo = -1; +static gint ett_z3950_SEQUENCE_OF_VariantClass = -1; +static gint ett_z3950_VariantClass = -1; +static gint ett_z3950_SEQUENCE_OF_VariantType = -1; +static gint ett_z3950_VariantType = -1; +static gint ett_z3950_VariantValue = -1; +static gint ett_z3950_ValueSet = -1; +static gint ett_z3950_SEQUENCE_OF_ValueDescription = -1; +static gint ett_z3950_ValueRange = -1; +static gint ett_z3950_ValueDescription = -1; +static gint ett_z3950_UnitInfo = -1; +static gint ett_z3950_SEQUENCE_OF_UnitType = -1; +static gint ett_z3950_UnitType = -1; +static gint ett_z3950_SEQUENCE_OF_Units = -1; +static gint ett_z3950_Units = -1; +static gint ett_z3950_CategoryList = -1; +static gint ett_z3950_SEQUENCE_OF_CategoryInfo = -1; +static gint ett_z3950_CategoryInfo = -1; +static gint ett_z3950_CommonInfo = -1; +static gint ett_z3950_HumanString = -1; +static gint ett_z3950_HumanString_item = -1; +static gint ett_z3950_IconObject = -1; +static gint ett_z3950_IconObject_item = -1; +static gint ett_z3950_T_bodyType = -1; +static gint ett_z3950_ContactInfo = -1; +static gint ett_z3950_NetworkAddress = -1; +static gint ett_z3950_T_internetAddress = -1; +static gint ett_z3950_T_osiPresentationAddress = -1; +static gint ett_z3950_T_networkAddress_other = -1; +static gint ett_z3950_AccessInfo = -1; +static gint ett_z3950_SEQUENCE_OF_QueryTypeDetails = -1; +static gint ett_z3950_T_diagnosticsSets = -1; +static gint ett_z3950_SEQUENCE_OF_AttributeSetId = -1; +static gint ett_z3950_T_schemas = -1; +static gint ett_z3950_T_recordSyntaxes = -1; +static gint ett_z3950_T_resourceChallenges = -1; +static gint ett_z3950_T_variantSets = -1; +static gint ett_z3950_SEQUENCE_OF_ElementSetName = -1; +static gint ett_z3950_QueryTypeDetails = -1; +static gint ett_z3950_PrivateCapabilities = -1; +static gint ett_z3950_T_privateCapabilities_operators = -1; +static gint ett_z3950_T_privateCapabilities_operators_item = -1; +static gint ett_z3950_SEQUENCE_OF_SearchKey = -1; +static gint ett_z3950_RpnCapabilities = -1; +static gint ett_z3950_T_operators = -1; +static gint ett_z3950_Iso8777Capabilities = -1; +static gint ett_z3950_ProximitySupport = -1; +static gint ett_z3950_T_unitsSupported = -1; +static gint ett_z3950_T_unitsSupported_item = -1; +static gint ett_z3950_T_proximitySupport_unitsSupported_item_private = -1; +static gint ett_z3950_SearchKey = -1; +static gint ett_z3950_AccessRestrictions = -1; +static gint ett_z3950_AccessRestrictions_item = -1; +static gint ett_z3950_T_accessChallenges = -1; +static gint ett_z3950_Costs = -1; +static gint ett_z3950_T_otherCharges = -1; +static gint ett_z3950_T_otherCharges_item = -1; +static gint ett_z3950_Charge = -1; +static gint ett_z3950_DatabaseList = -1; +static gint ett_z3950_AttributeCombinations = -1; +static gint ett_z3950_SEQUENCE_OF_AttributeCombination = -1; +static gint ett_z3950_AttributeCombination = -1; +static gint ett_z3950_AttributeOccurrence = -1; +static gint ett_z3950_T_attributeOccurrence_attributeValues = -1; +static gint ett_z3950_BriefBib = -1; +static gint ett_z3950_SEQUENCE_OF_FormatSpec = -1; +static gint ett_z3950_FormatSpec = -1; +static gint ett_z3950_GenericRecord = -1; +static gint ett_z3950_TaggedElement = -1; +static gint ett_z3950_ElementData = -1; +static gint ett_z3950_SEQUENCE_OF_TaggedElement = -1; +static gint ett_z3950_ElementMetaData = -1; +static gint ett_z3950_SEQUENCE_OF_HitVector = -1; +static gint ett_z3950_SEQUENCE_OF_Variant = -1; +static gint ett_z3950_TagPath = -1; +static gint ett_z3950_TagPath_item = -1; +static gint ett_z3950_Order = -1; +static gint ett_z3950_Usage = -1; +static gint ett_z3950_HitVector = -1; +static gint ett_z3950_Variant = -1; +static gint ett_z3950_T_triples = -1; +static gint ett_z3950_T_triples_item = -1; +static gint ett_z3950_T_variant_triples_item_value = -1; +static gint ett_z3950_TaskPackage = -1; +static gint ett_z3950_PromptObject = -1; +static gint ett_z3950_Challenge = -1; +static gint ett_z3950_Challenge_item = -1; +static gint ett_z3950_T_promptInfo = -1; +static gint ett_z3950_Response = -1; +static gint ett_z3950_Response_item = -1; +static gint ett_z3950_T_promptResponse = -1; +static gint ett_z3950_PromptId = -1; +static gint ett_z3950_T_enummeratedPrompt = -1; +static gint ett_z3950_Encryption = -1; +static gint ett_z3950_DES_RN_Object = -1; +static gint ett_z3950_DRNType = -1; +static gint ett_z3950_KRBObject = -1; +static gint ett_z3950_KRBRequest = -1; +static gint ett_z3950_KRBResponse = -1; +static gint ett_z3950_SearchInfoReport = -1; +static gint ett_z3950_SearchInfoReport_item = -1; +static gint ett_z3950_ResultsByDB = -1; +static gint ett_z3950_ResultsByDB_item = -1; +static gint ett_z3950_T_databases = -1; +static gint ett_z3950_QueryExpression = -1; +static gint ett_z3950_T_queryExpression_term = -1; + +/*--- End of included file: packet-z3950-ett.c ---*/ +#line 667 "./asn1/z3950/packet-z3950-template.c" + +/* MARC variables and forwards */ + +static int dissect_marc_record(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void * data _U_); + +/* MARC fields */ +static int hf_marc_record = -1; +static int hf_marc_record_terminator = -1; +static int hf_marc_leader = -1; +static int hf_marc_leader_length = -1; +static int hf_marc_leader_status = -1; +static int hf_marc_leader_type = -1; +static int hf_marc_leader_biblevel = -1; +static int hf_marc_leader_control = -1; +static int hf_marc_leader_encoding = -1; +static int hf_marc_leader_indicator_count = -1; +static int hf_marc_leader_subfield_count = -1; +static int hf_marc_leader_data_offset = -1; +static int hf_marc_leader_encoding_level = -1; +static int hf_marc_leader_descriptive_cataloging = -1; +static int hf_marc_leader_multipart_level = -1; +static int hf_marc_leader_length_of_field_length = -1; +static int hf_marc_leader_starting_character_position_length = -1; +static int hf_marc_leader_implementation_defined_length = -1; +static int hf_marc_directory = -1; +static int hf_marc_directory_entry = -1; +static int hf_marc_directory_entry_tag = -1; +static int hf_marc_directory_entry_length = -1; +static int hf_marc_directory_entry_starting_position = -1; +static int hf_marc_directory_terminator = -1; +static int hf_marc_fields = -1; +static int hf_marc_field = -1; +static int hf_marc_field_control = -1; +static int hf_marc_field_terminator = -1; +static int hf_marc_field_indicator1 = -1; +static int hf_marc_field_indicator2 = -1; +static int hf_marc_field_subfield_indicator = -1; +static int hf_marc_field_subfield_tag = -1; +static int hf_marc_field_subfield = -1; + +/* MARC subtree pointers */ +static int ett_marc_record = -1; +static int ett_marc_leader = -1; +static int ett_marc_directory = -1; +static int ett_marc_directory_entry = -1; +static int ett_marc_fields = -1; +static int ett_marc_field = -1; + +/* MARC expert fields */ +static expert_field ei_marc_invalid_length = EI_INIT; +static expert_field ei_marc_invalid_value = EI_INIT; +static expert_field ei_marc_invalid_record_length = EI_INIT; + +/* MARC value strings */ + +static const value_string marc_tag_names[] = { + { 1, "Control Number" }, + { 3, "Control Number Identifier" }, + { 5, "Date and Time of Latest Transaction" }, + { 6, "Fixed-length Data Elements - Addiional Matieral Characteristics" }, + { 8, "Fixed-length Data Elements" }, + { 7, "Physical Description Fixed Field" }, + { 10, "Library of Congress Control Number" }, + { 15, "National Bibliography Number" }, + { 16, "National Bibliographic Agency Control Number" }, + { 17, "Copyright or Legal Deposit Number" }, + { 20, "International Standard Book Number (ISBN)" }, + { 22, "International Standard Serial Number (ISSN)" }, + { 24, "Other Standard Identifier" }, + { 25, "Overseas Acquisition Number" }, + { 26, "Fingerprint Identifier" }, + { 27, "Standard Technical Report Number" }, + { 28, "Publisher or Distributor Number" }, + { 30, "CODEN Designation" }, + { 32, "Postal Registration Number" }, + { 33, "Date/Time and Place of an Event" }, + { 35, "System Control Number" }, + { 37, "Source of Acquisition" }, + { 38, "Record Content Licensor" }, + { 40, "Cataloging Source" }, + { 41, "Language Code" }, + { 42, "Authentication Code" }, + { 43, "Geographic Area Code" }, + { 44, "Country of Publishing/Producing Entity Code" }, + { 45, "Time Period of Content" }, + { 47, "Form of Musical Composition Code" }, + { 50, "Library of Congress Call Number" }, + { 51, "Library of Congress Copy, Issue, Offprint Statement" }, + { 60, "National Library of Medicine Call Number" }, + { 66, "Character Sets Present" }, + { 80, "Universal Decimal Classification Number" }, + { 82, "Dewey Decimal Classification Number" }, + { 83, "Additional Dewey Decimal Classification Number" }, + { 84, "Other Classification Number" }, + { 100, "Main Entry - Personal Name" }, + { 110, "Main Entry - Corporate Name" }, + { 111, "Main Entry - Meeting Name" }, + { 130, "Main Entry - Uniform Title" }, + { 210, "Abbreviated Title" }, + { 222, "Key Title" }, + { 240, "Uniform Title" }, + { 242, "Translation of Title by Cataloging Agency" }, + { 243, "Collective Uniform Title" }, + { 245, "Title Statement" }, + { 246, "Varying Form of Title" }, + { 247, "Former Title" }, + { 249, "Local LoC Varying Form of Title" }, + { 250, "Edition Statement" }, + { 260, "Publication, Distribution, etc. (Imprint)" }, + { 264, "Production, Publication, Distribution, Manufacture, and Copyright Notice" }, + { 300, "Physical Description" }, + { 310, "Current Publication Frequency" }, + { 321, "former Publication Frequency" }, + { 336, "Content Type" }, + { 337, "Media Type" }, + { 338, "Carrier Type" }, + { 340, "Physical Medium" }, + { 362, "Dates of Publication and/or Sequential Designation" }, + { 400, "Series Statement/Added Entry-Personal Name" }, + { 410, "Series Statement/Added Entry-Corporate Name" }, + { 411, "Series Statement/Added Entry-Meeting Name" }, + { 440, "Series Statement/Added Entry-Title" }, + { 490, "Series Statement" }, + { 500, "General Note" }, + { 504, "Bibliography, etc. Note" }, + { 505, "Formatted Contents Note" }, + { 506, "Restrictions on Access Note" }, + { 508, "Creation/Production Credits Note" }, + { 510, "Citation/References Note" }, + { 511, "Participant or Performer Note" }, + { 515, "Numbering Peculiarities Note" }, + { 518, "Date/Time and Place of an Event Note" }, + { 520, "Summary, etc." }, + { 521, "Target Audience Note" }, + { 522, "Geographic Coverage Note" }, + { 524, "Preferred Citation of Described Materials Note" }, + { 525, "Supplement Note" }, + { 530, "Additional Physical Form available Note" }, + { 532, "Accessibility Note" }, + { 533, "Reproduction Note" }, + { 534, "Original Version Note" }, + { 538, "System Details Note" }, + { 540, "Terms Governing Use and Reproduction Note" }, + { 541, "Immediate Source of Acquisition Note" }, + { 542, "Information Relating to Copyright Status" }, + { 546, "Language Note" }, + { 550, "Issuing Body Note" }, + { 555, "Cumulative Index/Finding Aids Note" }, + { 583, "Action Note" }, + { 588, "Source of Description, Etc. Note" }, + { 590, "Local LoC Note" }, + { 591, "Local LoC \"With\" Note" }, + { 592, "Local LoC Acquisition Note" }, + { 600, "Subject Added Entry - Personal Name" }, + { 610, "Subject Added Entry - Corporate Name" }, + { 611, "Subject Added Entry - Meeting Name" }, + { 630, "Subject Added Entry - Uniform Title" }, + { 647, "Subject Added Entry - Named Event" }, + { 648, "Subject Added Entry - Chronological Term" }, + { 650, "Subject Added Entry - Topical Term" }, + { 651, "Subject Added Entry - Geographic Name" }, + { 653, "Index Term - Uncontrolled" }, + { 654, "Subject Added Entry - Faceted Topical Terms" }, + { 655, "Index Term - Genre/Form" }, + { 656, "Index Term - Occupation" }, + { 657, "Index Term - Function" }, + { 658, "Index Term - Curriculum Objective" }, + { 662, "Subject Added Entry - Hierarchical Place Name" }, + { 700, "Added Entry - Personal Name" }, + { 710, "Added Entry - Corporate Name" }, + { 711, "Added Entry - Meeting Name" }, + { 720, "Added Entry - Uncontrolled Name" }, + { 730, "Added Entry - Uniform Title" }, + { 740, "Added Entry - Uncontrolled Related/Analytical Title" }, + { 751, "Added Entry - Geographic Name" }, + { 752, "Added Entry - Hierarchical Place Name" }, + { 753, "System Details Access to Computer Files" }, + { 754, "Added Entry - Taxonomic Identification" }, + { 758, "Resource Identifier" }, + { 760, "Main Series Entry" }, + { 762, "Subseries Entry" }, + { 765, "Original Language Entry" }, + { 767, "Translation Entry" }, + { 770, "Supplement/Special Issue Entry" }, + { 772, "Supplement Parent Entry" }, + { 773, "Host Item Entry" }, + { 774, "Constituent Unit Entry" }, + { 775, "Other Edition Entry" }, + { 776, "Additional Physical Form Entry" }, + { 777, "Issued With Entry" }, + { 780, "Preceding Entry" }, + { 785, "Succeeding Entry" }, + { 786, "Data Source Entry" }, + { 787, "Other Relationship Entry" }, + { 800, "Series Added Entry - Personal Name" }, + { 810, "Series Added Entry - Corporate Name" }, + { 811, "Series Added Entry - Meeting Name" }, + { 830, "Series Added Entry - Uniform Title" }, + { 850, "Holding Institution" }, + { 852, "Location" }, + { 853, "Captions and Pattern - Basic Bibliographic Unit" }, + { 856, "Electronic Location and Access" }, + { 859, "Local LoC Electronic Location and Access" }, + { 863, "Enumeration and Chronology - Basic Bibliographic Unit" }, + { 880, "Alternate Graphic Representation" }, + { 890, "Local LoC Visible File Entry" }, + { 906, "Local LoC Processing Data" }, + { 920, "Local LoC Selection Decision" }, + { 922, "Local LoC Book Source" }, + { 923, "Local LoC Supplier Invoice or Shipment Id" }, + { 925, "Local LoC Selection Decision" }, + { 952, "Local LoC Cataloger's Permanent Note" }, + { 955, "Local LoC Functional Identifying Information" }, + { 984, "Local LoC Shelflist Compare Status" }, + { 985, "Local LoC Record History" }, + { 987, "Local LoC Converstion History" }, + { 991, "Local LoC Location Information" }, + { 992, "Local LoC Location Information" }, + { 0, NULL} +}; + +static int +dissect_z3950_printable_OCTET_STRING(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + tvbuff_t *next_tvb = NULL; + int hf_alternate = -1; + guint old_offset = offset; + + if (hf_index == hf_z3950_referenceId) { + hf_alternate = hf_z3950_referenceId_printable; + } + else if ( hf_index == hf_z3950_general) { + hf_alternate = hf_z3950_general_printable; + } + + if (hf_alternate > 0) { + /* extract the value of the octet string so we can look at it. */ + /* This does not display anything because tree is NULL. */ + offset = dissect_ber_octet_string(implicit_tag, actx, NULL, tvb, offset, hf_index, &next_tvb); + + if (next_tvb && + tvb_ascii_isprint(next_tvb, 0, tvb_reported_length(next_tvb))) { + proto_tree_add_item(tree, hf_alternate, next_tvb, + 0, tvb_reported_length(next_tvb), ENC_ASCII|ENC_NA); + } + else { + offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, + old_offset, hf_index, NULL); + } + } + else { + offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, + old_offset, hf_index, NULL); + } + + return offset; +} + + +/*--- Included file: packet-z3950-fn.c ---*/ +#line 1 "./asn1/z3950/packet-z3950-fn.c" +/*--- Cyclic dependencies ---*/ + +/* RPNStructure -> RPNStructure/rpnRpnOp -> RPNStructure */ +/* RPNStructure -> RPNStructure/rpnRpnOp -> RPNStructure */ +static int dissect_z3950_RPNStructure(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_); + +/* ElementInfo -> ElementDataType -> ElementDataType/structured -> ElementInfo */ +static int dissect_z3950_ElementInfo(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_); + +/* TaggedElement -> ElementData -> ElementData/subtree -> TaggedElement */ +static int dissect_z3950_TaggedElement(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_); + + + + +static int +dissect_z3950_OCTET_STRING(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + + +static int +dissect_z3950_ReferenceId(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { +#line 142 "./asn1/z3950/z3950.cnf" + offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset, + hf_index, BER_CLASS_CON, 2, TRUE, + dissect_z3950_printable_OCTET_STRING); + + + + return offset; +} + + +static const asn_namedbit ProtocolVersion_U_bits[] = { + { 0, &hf_z3950_ProtocolVersion_U_version_1, -1, -1, "version-1", NULL }, + { 1, &hf_z3950_ProtocolVersion_U_version_2, -1, -1, "version-2", NULL }, + { 2, &hf_z3950_ProtocolVersion_U_version_3, -1, -1, "version-3", NULL }, + { 0, NULL, 0, 0, NULL, NULL } +}; + +static int +dissect_z3950_ProtocolVersion_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_bitstring(implicit_tag, actx, tree, tvb, offset, + ProtocolVersion_U_bits, hf_index, ett_z3950_ProtocolVersion_U, + NULL); + + return offset; +} + + + +static int +dissect_z3950_ProtocolVersion(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset, + hf_index, BER_CLASS_CON, 3, TRUE, dissect_z3950_ProtocolVersion_U); + + return offset; +} + + +static const asn_namedbit Options_U_bits[] = { + { 0, &hf_z3950_Options_U_search, -1, -1, "search", NULL }, + { 1, &hf_z3950_Options_U_present, -1, -1, "present", NULL }, + { 2, &hf_z3950_Options_U_delSet, -1, -1, "delSet", NULL }, + { 3, &hf_z3950_Options_U_resourceReport, -1, -1, "resourceReport", NULL }, + { 4, &hf_z3950_Options_U_triggerResourceCtrl, -1, -1, "triggerResourceCtrl", NULL }, + { 5, &hf_z3950_Options_U_resourceCtrl, -1, -1, "resourceCtrl", NULL }, + { 6, &hf_z3950_Options_U_accessCtrl, -1, -1, "accessCtrl", NULL }, + { 7, &hf_z3950_Options_U_scan, -1, -1, "scan", NULL }, + { 8, &hf_z3950_Options_U_sort, -1, -1, "sort", NULL }, + { 10, &hf_z3950_Options_U_extendedServices, -1, -1, "extendedServices", NULL }, + { 11, &hf_z3950_Options_U_level_1Segmentation, -1, -1, "level-1Segmentation", NULL }, + { 12, &hf_z3950_Options_U_level_2Segmentation, -1, -1, "level-2Segmentation", NULL }, + { 13, &hf_z3950_Options_U_concurrentOperations, -1, -1, "concurrentOperations", NULL }, + { 14, &hf_z3950_Options_U_namedResultSets, -1, -1, "namedResultSets", NULL }, + { 0, NULL, 0, 0, NULL, NULL } +}; + +static int +dissect_z3950_Options_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_bitstring(implicit_tag, actx, tree, tvb, offset, + Options_U_bits, hf_index, ett_z3950_Options_U, + NULL); + + return offset; +} + + + +static int +dissect_z3950_Options(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset, + hf_index, BER_CLASS_CON, 4, TRUE, dissect_z3950_Options_U); + + return offset; +} + + + +static int +dissect_z3950_INTEGER(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + + +static int +dissect_z3950_VisibleString(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_restricted_string(implicit_tag, BER_UNI_TAG_VisibleString, + actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + + +static int +dissect_z3950_InternationalString(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_restricted_string(implicit_tag, BER_UNI_TAG_GeneralString, + actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const ber_sequence_t T_idPass_sequence[] = { + { &hf_z3950_groupId , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_userId , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_password , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_idPass(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_idPass_sequence, hf_index, ett_z3950_T_idPass); + + return offset; +} + + + +static int +dissect_z3950_NULL(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_null(implicit_tag, actx, tree, tvb, offset, hf_index); + + return offset; +} + + + +static int +dissect_z3950_EXTERNAL(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_external_type(implicit_tag, tree, tvb, offset, actx, hf_index, NULL); + + return offset; +} + + +static const value_string z3950_T_idAuthentication_vals[] = { + { 0, "open" }, + { 1, "idPass" }, + { 2, "anonymous" }, + { 3, "other" }, + { 0, NULL } +}; + +static const ber_choice_t T_idAuthentication_choice[] = { + { 0, &hf_z3950_open , BER_CLASS_UNI, BER_UNI_TAG_VisibleString, BER_FLAGS_NOOWNTAG, dissect_z3950_VisibleString }, + { 1, &hf_z3950_idPass , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_T_idPass }, + { 2, &hf_z3950_anonymous , BER_CLASS_UNI, BER_UNI_TAG_NULL, BER_FLAGS_NOOWNTAG, dissect_z3950_NULL }, + { 3, &hf_z3950_other , BER_CLASS_UNI, BER_UNI_TAG_EXTERNAL, BER_FLAGS_NOOWNTAG, dissect_z3950_EXTERNAL }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_idAuthentication(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_idAuthentication_choice, hf_index, ett_z3950_T_idAuthentication, + NULL); + + return offset; +} + + + +static int +dissect_z3950_OBJECT_IDENTIFIER(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_object_identifier(implicit_tag, actx, tree, tvb, offset, hf_index, NULL); + + return offset; +} + + +static const ber_sequence_t InfoCategory_sequence[] = { + { &hf_z3950_categoryTypeId, BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { &hf_z3950_categoryValue , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_InfoCategory(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + InfoCategory_sequence, hf_index, ett_z3950_InfoCategory); + + return offset; +} + + +static const value_string z3950_T_information_vals[] = { + { 2, "characterInfo" }, + { 3, "binaryInfo" }, + { 4, "externallyDefinedInfo" }, + { 5, "oid" }, + { 0, NULL } +}; + +static const ber_choice_t T_information_choice[] = { + { 2, &hf_z3950_characterInfo , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { 3, &hf_z3950_binaryInfo , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_OCTET_STRING }, + { 4, &hf_z3950_externallyDefinedInfo, BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_z3950_EXTERNAL }, + { 5, &hf_z3950_oid , BER_CLASS_CON, 5, BER_FLAGS_IMPLTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_information(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_information_choice, hf_index, ett_z3950_T_information, + NULL); + + return offset; +} + + +static const ber_sequence_t T__untag_item_sequence[] = { + { &hf_z3950_category , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InfoCategory }, + { &hf_z3950_information , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_T_information }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T__untag_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T__untag_item_sequence, hf_index, ett_z3950_T__untag_item); + + return offset; +} + + +static const ber_sequence_t OtherInformation_U_sequence_of[1] = { + { &hf_z3950_otherInformation_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_T__untag_item }, +}; + +static int +dissect_z3950_OtherInformation_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + OtherInformation_U_sequence_of, hf_index, ett_z3950_OtherInformation_U); + + return offset; +} + + + +static int +dissect_z3950_OtherInformation(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset, + hf_index, BER_CLASS_CON, 201, TRUE, dissect_z3950_OtherInformation_U); + + return offset; +} + + +static const ber_sequence_t InitializeRequest_sequence[] = { + { &hf_z3950_referenceId , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_protocolVersion, BER_CLASS_CON, 3, BER_FLAGS_NOOWNTAG, dissect_z3950_ProtocolVersion }, + { &hf_z3950_options , BER_CLASS_CON, 4, BER_FLAGS_NOOWNTAG, dissect_z3950_Options }, + { &hf_z3950_preferredMessageSize, BER_CLASS_CON, 5, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_exceptionalRecordSize, BER_CLASS_CON, 6, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_idAuthentication, BER_CLASS_CON, 7, BER_FLAGS_OPTIONAL, dissect_z3950_T_idAuthentication }, + { &hf_z3950_implementationId, BER_CLASS_CON, 110, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_implementationName, BER_CLASS_CON, 111, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_implementationVersion, BER_CLASS_CON, 112, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_userInformationField, BER_CLASS_CON, 11, BER_FLAGS_OPTIONAL, dissect_z3950_EXTERNAL }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_InitializeRequest(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + InitializeRequest_sequence, hf_index, ett_z3950_InitializeRequest); + + return offset; +} + + + +static int +dissect_z3950_BOOLEAN(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_boolean(implicit_tag, actx, tree, tvb, offset, hf_index, NULL); + + return offset; +} + + +static const ber_sequence_t InitializeResponse_sequence[] = { + { &hf_z3950_referenceId , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_protocolVersion, BER_CLASS_CON, 3, BER_FLAGS_NOOWNTAG, dissect_z3950_ProtocolVersion }, + { &hf_z3950_options , BER_CLASS_CON, 4, BER_FLAGS_NOOWNTAG, dissect_z3950_Options }, + { &hf_z3950_preferredMessageSize, BER_CLASS_CON, 5, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_exceptionalRecordSize, BER_CLASS_CON, 6, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_result , BER_CLASS_CON, 12, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_implementationId, BER_CLASS_CON, 110, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_implementationName, BER_CLASS_CON, 111, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_implementationVersion, BER_CLASS_CON, 112, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_userInformationField, BER_CLASS_CON, 11, BER_FLAGS_OPTIONAL, dissect_z3950_EXTERNAL }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_InitializeResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + InitializeResponse_sequence, hf_index, ett_z3950_InitializeResponse); + + return offset; +} + + + +static int +dissect_z3950_DatabaseName(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset, + hf_index, BER_CLASS_CON, 105, TRUE, dissect_z3950_InternationalString); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_DatabaseName_sequence_of[1] = { + { &hf_z3950_databaseNames_item, BER_CLASS_CON, 105, BER_FLAGS_NOOWNTAG, dissect_z3950_DatabaseName }, +}; + +static int +dissect_z3950_SEQUENCE_OF_DatabaseName(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_DatabaseName_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_DatabaseName); + + return offset; +} + + + +static int +dissect_z3950_ElementSetName(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset, + hf_index, BER_CLASS_CON, 103, TRUE, dissect_z3950_InternationalString); + + return offset; +} + + +static const ber_sequence_t T_databaseSpecific_item_sequence[] = { + { &hf_z3950_dbName , BER_CLASS_CON, 105, BER_FLAGS_NOOWNTAG, dissect_z3950_DatabaseName }, + { &hf_z3950_esn , BER_CLASS_CON, 103, BER_FLAGS_NOOWNTAG, dissect_z3950_ElementSetName }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_databaseSpecific_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_databaseSpecific_item_sequence, hf_index, ett_z3950_T_databaseSpecific_item); + + return offset; +} + + +static const ber_sequence_t T_databaseSpecific_sequence_of[1] = { + { &hf_z3950_databaseSpecific_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_T_databaseSpecific_item }, +}; + +static int +dissect_z3950_T_databaseSpecific(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_databaseSpecific_sequence_of, hf_index, ett_z3950_T_databaseSpecific); + + return offset; +} + + +static const value_string z3950_ElementSetNames_vals[] = { + { 0, "genericElementSetName" }, + { 1, "databaseSpecific" }, + { 0, NULL } +}; + +static const ber_choice_t ElementSetNames_choice[] = { + { 0, &hf_z3950_genericElementSetName, BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { 1, &hf_z3950_databaseSpecific, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_T_databaseSpecific }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ElementSetNames(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + ElementSetNames_choice, hf_index, ett_z3950_ElementSetNames, + NULL); + + return offset; +} + + + +static int +dissect_z3950_T_type_0(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { +#line 139 "./asn1/z3950/z3950.cnf" +/*XXX Not implemented yet */ + + + + return offset; +} + + + +static int +dissect_z3950_AttributeSetId(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { +#line 152 "./asn1/z3950/z3950.cnf" + tvbuff_t *oid_tvb=NULL; + + + offset = dissect_ber_object_identifier(implicit_tag, actx, tree, tvb, offset, hf_index, &oid_tvb); + +#line 156 "./asn1/z3950/z3950.cnf" + if (oid_tvb) { + guint len = tvb_reported_length_remaining(oid_tvb, 0); + gchar *oid_str = oid_encoded2string(wmem_packet_scope(), + tvb_get_ptr(oid_tvb, 0, len), len); + gint attribute_set_idx = Z3950_ATSET_UNKNOWN; + z3950_atinfo_t *atinfo_data; + packet_info *pinfo = actx->pinfo; + + if (g_strcmp0(oid_str, Z3950_ATSET_BIB1_OID) == 0) { + attribute_set_idx = Z3950_ATSET_BIB1; + } + if ((atinfo_data = (z3950_atinfo_t *)p_get_proto_data(pinfo->pool, pinfo, proto_z3950, Z3950_ATINFO_KEY)) == NULL) { + + atinfo_data = wmem_new0(pinfo->pool, z3950_atinfo_t); + atinfo_data->atsetidx = attribute_set_idx; + p_add_proto_data(pinfo->pool, pinfo, + proto_z3950, Z3950_ATINFO_KEY, atinfo_data); + } + else { + atinfo_data->atsetidx = attribute_set_idx; + } + } + + + return offset; +} + + + +static int +dissect_z3950_T_attributeElement_attributeType(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { +#line 180 "./asn1/z3950/z3950.cnf" + gint att_type=0; + packet_info *pinfo = actx->pinfo; + z3950_atinfo_t *atinfo_data; + + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + &att_type); + +#line 185 "./asn1/z3950/z3950.cnf" + atinfo_data = (z3950_atinfo_t *)p_get_proto_data(pinfo->pool, pinfo, proto_z3950, Z3950_ATINFO_KEY); + if (atinfo_data && atinfo_data->atsetidx == Z3950_ATSET_BIB1) { + proto_item_append_text(actx->created_item, " (%s)", + val_to_str(att_type, z3950_bib1_att_types, "Unknown bib-1 attributeType %d")); + atinfo_data->attype = att_type; + } + + return offset; +} + + + +static int +dissect_z3950_T_attributeValue_numeric(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { +#line 192 "./asn1/z3950/z3950.cnf" + gint att_value=0; + packet_info *pinfo = actx->pinfo; + z3950_atinfo_t *atinfo_data; + const value_string *att_value_string = NULL; + + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + &att_value); + +#line 198 "./asn1/z3950/z3950.cnf" + atinfo_data = (z3950_atinfo_t *)p_get_proto_data(pinfo->pool, pinfo, proto_z3950, Z3950_ATINFO_KEY); + if (atinfo_data && atinfo_data->atsetidx == Z3950_ATSET_BIB1) { + switch (atinfo_data->attype) { + case Z3950_BIB1_AT_USE: + att_value_string = z3950_bib1_at_use; + break; + case Z3950_BIB1_AT_RELATION: + att_value_string = z3950_bib1_at_relation; + break; + case Z3950_BIB1_AT_POSITION: + att_value_string = z3950_bib1_at_position; + break; + case Z3950_BIB1_AT_STRUCTURE: + att_value_string = z3950_bib1_at_structure; + break; + case Z3950_BIB1_AT_TRUNCATION: + att_value_string = z3950_bib1_at_truncation; + break; + case Z3950_BIB1_AT_COMPLETENESS: + att_value_string = z3950_bib1_at_completeness; + break; + default: + att_value_string = NULL; + } + if (att_value_string) { + proto_item_append_text(actx->created_item, " (%s)", + val_to_str(att_value, att_value_string, "Unknown bib-1 attributeValue %d")); + } + } + + return offset; +} + + +static const value_string z3950_StringOrNumeric_vals[] = { + { 1, "string" }, + { 2, "numeric" }, + { 0, NULL } +}; + +static const ber_choice_t StringOrNumeric_choice[] = { + { 1, &hf_z3950_string , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { 2, &hf_z3950_numeric , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_StringOrNumeric(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + StringOrNumeric_choice, hf_index, ett_z3950_StringOrNumeric, + NULL); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_StringOrNumeric_sequence_of[1] = { + { &hf_z3950_attributeValue_complex_list_item, BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_StringOrNumeric }, +}; + +static int +dissect_z3950_SEQUENCE_OF_StringOrNumeric(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_StringOrNumeric_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_StringOrNumeric); + + return offset; +} + + +static const ber_sequence_t T_semanticAction_sequence_of[1] = { + { &hf_z3950_semanticAction_item, BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_z3950_INTEGER }, +}; + +static int +dissect_z3950_T_semanticAction(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_semanticAction_sequence_of, hf_index, ett_z3950_T_semanticAction); + + return offset; +} + + +static const ber_sequence_t T_attributeValue_complex_sequence[] = { + { &hf_z3950_attributeValue_complex_list, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_StringOrNumeric }, + { &hf_z3950_semanticAction, BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_semanticAction }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_attributeValue_complex(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_attributeValue_complex_sequence, hf_index, ett_z3950_T_attributeValue_complex); + + return offset; +} + + +static const value_string z3950_T_attributeValue_vals[] = { + { 121, "numeric" }, + { 224, "complex" }, + { 0, NULL } +}; + +static const ber_choice_t T_attributeValue_choice[] = { + { 121, &hf_z3950_attributeValue_numeric, BER_CLASS_CON, 121, BER_FLAGS_IMPLTAG, dissect_z3950_T_attributeValue_numeric }, + { 224, &hf_z3950_attributeValue_complex, BER_CLASS_CON, 224, BER_FLAGS_IMPLTAG, dissect_z3950_T_attributeValue_complex }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_attributeValue(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_attributeValue_choice, hf_index, ett_z3950_T_attributeValue, + NULL); + + return offset; +} + + +static const ber_sequence_t AttributeElement_sequence[] = { + { &hf_z3950_attributeSet , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_AttributeSetId }, + { &hf_z3950_attributeElement_attributeType, BER_CLASS_CON, 120, BER_FLAGS_IMPLTAG, dissect_z3950_T_attributeElement_attributeType }, + { &hf_z3950_attributeValue, BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_T_attributeValue }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_AttributeElement(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + AttributeElement_sequence, hf_index, ett_z3950_AttributeElement); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_AttributeElement_sequence_of[1] = { + { &hf_z3950_attributeList_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_AttributeElement }, +}; + +static int +dissect_z3950_SEQUENCE_OF_AttributeElement(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_AttributeElement_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_AttributeElement); + + return offset; +} + + + +static int +dissect_z3950_AttributeList(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset, + hf_index, BER_CLASS_CON, 44, TRUE, dissect_z3950_SEQUENCE_OF_AttributeElement); + + return offset; +} + + + +static int +dissect_z3950_T_general(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { +#line 147 "./asn1/z3950/z3950.cnf" + offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset, + hf_index, BER_CLASS_CON, 2, TRUE, + dissect_z3950_printable_OCTET_STRING); + + + + return offset; +} + + + +static int +dissect_z3950_GeneralizedTime(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_GeneralizedTime(implicit_tag, actx, tree, tvb, offset, hf_index); + + return offset; +} + + +static const ber_sequence_t Unit_sequence[] = { + { &hf_z3950_unitSystem , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL, dissect_z3950_InternationalString }, + { &hf_z3950_unitType , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOTCHKTAG, dissect_z3950_StringOrNumeric }, + { &hf_z3950_unit , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_NOTCHKTAG, dissect_z3950_StringOrNumeric }, + { &hf_z3950_scaleFactor , BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Unit(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + Unit_sequence, hf_index, ett_z3950_Unit); + + return offset; +} + + +static const ber_sequence_t IntUnit_sequence[] = { + { &hf_z3950_value , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_unitUsed , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_Unit }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_IntUnit(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + IntUnit_sequence, hf_index, ett_z3950_IntUnit); + + return offset; +} + + +static const value_string z3950_Term_vals[] = { + { 45, "general" }, + { 215, "numeric" }, + { 216, "characterString" }, + { 217, "oid" }, + { 218, "dateTime" }, + { 219, "external" }, + { 220, "integerAndUnit" }, + { 221, "null" }, + { 0, NULL } +}; + +static const ber_choice_t Term_choice[] = { + { 45, &hf_z3950_general , BER_CLASS_CON, 45, BER_FLAGS_IMPLTAG, dissect_z3950_T_general }, + { 215, &hf_z3950_numeric , BER_CLASS_CON, 215, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { 216, &hf_z3950_characterString, BER_CLASS_CON, 216, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { 217, &hf_z3950_oid , BER_CLASS_CON, 217, BER_FLAGS_IMPLTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { 218, &hf_z3950_dateTime , BER_CLASS_CON, 218, BER_FLAGS_IMPLTAG, dissect_z3950_GeneralizedTime }, + { 219, &hf_z3950_external , BER_CLASS_CON, 219, BER_FLAGS_IMPLTAG, dissect_z3950_EXTERNAL }, + { 220, &hf_z3950_integerAndUnit, BER_CLASS_CON, 220, BER_FLAGS_IMPLTAG, dissect_z3950_IntUnit }, + { 221, &hf_z3950_null , BER_CLASS_CON, 221, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Term(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + Term_choice, hf_index, ett_z3950_Term, + NULL); + + return offset; +} + + +static const ber_sequence_t AttributesPlusTerm_U_sequence[] = { + { &hf_z3950_attributes , BER_CLASS_CON, 44, BER_FLAGS_NOOWNTAG, dissect_z3950_AttributeList }, + { &hf_z3950_term , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_Term }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_AttributesPlusTerm_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + AttributesPlusTerm_U_sequence, hf_index, ett_z3950_AttributesPlusTerm_U); + + return offset; +} + + + +static int +dissect_z3950_AttributesPlusTerm(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset, + hf_index, BER_CLASS_CON, 102, TRUE, dissect_z3950_AttributesPlusTerm_U); + + return offset; +} + + + +static int +dissect_z3950_ResultSetId(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset, + hf_index, BER_CLASS_CON, 31, TRUE, dissect_z3950_InternationalString); + + return offset; +} + + +static const ber_sequence_t ResultSetPlusAttributes_U_sequence[] = { + { &hf_z3950_resultSet , BER_CLASS_CON, 31, BER_FLAGS_NOOWNTAG, dissect_z3950_ResultSetId }, + { &hf_z3950_attributes , BER_CLASS_CON, 44, BER_FLAGS_NOOWNTAG, dissect_z3950_AttributeList }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ResultSetPlusAttributes_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + ResultSetPlusAttributes_U_sequence, hf_index, ett_z3950_ResultSetPlusAttributes_U); + + return offset; +} + + + +static int +dissect_z3950_ResultSetPlusAttributes(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset, + hf_index, BER_CLASS_CON, 214, TRUE, dissect_z3950_ResultSetPlusAttributes_U); + + return offset; +} + + +static const value_string z3950_Operand_vals[] = { + { 102, "attrTerm" }, + { 31, "resultSet" }, + { 214, "resultAttr" }, + { 0, NULL } +}; + +static const ber_choice_t Operand_choice[] = { + { 102, &hf_z3950_attrTerm , BER_CLASS_CON, 102, BER_FLAGS_NOOWNTAG, dissect_z3950_AttributesPlusTerm }, + { 31, &hf_z3950_resultSet , BER_CLASS_CON, 31, BER_FLAGS_NOOWNTAG, dissect_z3950_ResultSetId }, + { 214, &hf_z3950_resultAttr , BER_CLASS_CON, 214, BER_FLAGS_NOOWNTAG, dissect_z3950_ResultSetPlusAttributes }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Operand(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + Operand_choice, hf_index, ett_z3950_Operand, + NULL); + + return offset; +} + + +static const value_string z3950_T_relationType_vals[] = { + { 1, "lessThan" }, + { 2, "lessThanOrEqual" }, + { 3, "equal" }, + { 4, "greaterThanOrEqual" }, + { 5, "greaterThan" }, + { 6, "notEqual" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_relationType(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const value_string z3950_KnownProximityUnit_vals[] = { + { 1, "character" }, + { 2, "word" }, + { 3, "sentence" }, + { 4, "paragraph" }, + { 5, "section" }, + { 6, "chapter" }, + { 7, "document" }, + { 8, "element" }, + { 9, "subelement" }, + { 10, "elementType" }, + { 11, "byte" }, + { 0, NULL } +}; + + +static int +dissect_z3950_KnownProximityUnit(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const value_string z3950_T_proximityUnitCode_vals[] = { + { 1, "known" }, + { 2, "private" }, + { 0, NULL } +}; + +static const ber_choice_t T_proximityUnitCode_choice[] = { + { 1, &hf_z3950_known , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_KnownProximityUnit }, + { 2, &hf_z3950_private , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_proximityUnitCode(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_proximityUnitCode_choice, hf_index, ett_z3950_T_proximityUnitCode, + NULL); + + return offset; +} + + +static const ber_sequence_t ProximityOperator_sequence[] = { + { &hf_z3950_exclusion , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_distance , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_ordered , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_relationType , BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_z3950_T_relationType }, + { &hf_z3950_proximityUnitCode, BER_CLASS_CON, 5, 0, dissect_z3950_T_proximityUnitCode }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ProximityOperator(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + ProximityOperator_sequence, hf_index, ett_z3950_ProximityOperator); + + return offset; +} + + +static const value_string z3950_Operator_U_vals[] = { + { 0, "and" }, + { 1, "or" }, + { 2, "and-not" }, + { 3, "prox" }, + { 0, NULL } +}; + +static const ber_choice_t Operator_U_choice[] = { + { 0, &hf_z3950_and , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 1, &hf_z3950_or , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 2, &hf_z3950_and_not , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 3, &hf_z3950_prox , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_ProximityOperator }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Operator_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + Operator_U_choice, hf_index, ett_z3950_Operator_U, + NULL); + + return offset; +} + + + +static int +dissect_z3950_Operator(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset, + hf_index, BER_CLASS_CON, 46, FALSE, dissect_z3950_Operator_U); + + return offset; +} + + +static const ber_sequence_t T_rpnRpnOp_sequence[] = { + { &hf_z3950_rpn1 , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_RPNStructure }, + { &hf_z3950_rpn2 , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_RPNStructure }, + { &hf_z3950_operatorRpnOp , BER_CLASS_CON, 46, BER_FLAGS_NOOWNTAG, dissect_z3950_Operator }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_rpnRpnOp(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_rpnRpnOp_sequence, hf_index, ett_z3950_T_rpnRpnOp); + + return offset; +} + + +static const value_string z3950_RPNStructure_vals[] = { + { 0, "op" }, + { 1, "rpnRpnOp" }, + { 0, NULL } +}; + +static const ber_choice_t RPNStructure_choice[] = { + { 0, &hf_z3950_operandRpnOp , BER_CLASS_CON, 0, 0, dissect_z3950_Operand }, + { 1, &hf_z3950_rpnRpnOp , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_T_rpnRpnOp }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_RPNStructure(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + RPNStructure_choice, hf_index, ett_z3950_RPNStructure, + NULL); + + return offset; +} + + +static const ber_sequence_t RPNQuery_sequence[] = { + { &hf_z3950_attributeSet , BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_z3950_AttributeSetId }, + { &hf_z3950_rpn , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_RPNStructure }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_RPNQuery(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + RPNQuery_sequence, hf_index, ett_z3950_RPNQuery); + + return offset; +} + + +static const value_string z3950_Query_vals[] = { + { 0, "type-0" }, + { 1, "type-1" }, + { 2, "type-2" }, + { 100, "type-100" }, + { 101, "type-101" }, + { 102, "type-102" }, + { 0, NULL } +}; + +static const ber_choice_t Query_choice[] = { + { 0, &hf_z3950_type_0 , BER_CLASS_CON, 0, 0, dissect_z3950_T_type_0 }, + { 1, &hf_z3950_type_1 , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_RPNQuery }, + { 2, &hf_z3950_type_2 , BER_CLASS_CON, 2, 0, dissect_z3950_OCTET_STRING }, + { 100, &hf_z3950_type_100 , BER_CLASS_CON, 100, 0, dissect_z3950_OCTET_STRING }, + { 101, &hf_z3950_type_101 , BER_CLASS_CON, 101, BER_FLAGS_IMPLTAG, dissect_z3950_RPNQuery }, + { 102, &hf_z3950_type_102 , BER_CLASS_CON, 102, 0, dissect_z3950_OCTET_STRING }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Query(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + Query_choice, hf_index, ett_z3950_Query, + NULL); + + return offset; +} + + +static const ber_sequence_t SearchRequest_sequence[] = { + { &hf_z3950_referenceId , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_smallSetUpperBound, BER_CLASS_CON, 13, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_largeSetLowerBound, BER_CLASS_CON, 14, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_mediumSetPresentNumber, BER_CLASS_CON, 15, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_replaceIndicator, BER_CLASS_CON, 16, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_resultSetName , BER_CLASS_CON, 17, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_databaseNames , BER_CLASS_CON, 18, BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_DatabaseName }, + { &hf_z3950_smallSetElementSetNames, BER_CLASS_CON, 100, BER_FLAGS_OPTIONAL|BER_FLAGS_NOTCHKTAG, dissect_z3950_ElementSetNames }, + { &hf_z3950_mediumSetElementSetNames, BER_CLASS_CON, 101, BER_FLAGS_OPTIONAL|BER_FLAGS_NOTCHKTAG, dissect_z3950_ElementSetNames }, + { &hf_z3950_preferredRecordSyntax, BER_CLASS_CON, 104, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { &hf_z3950_query , BER_CLASS_CON, 21, BER_FLAGS_NOTCHKTAG, dissect_z3950_Query }, + { &hf_z3950_additionalSearchInfo, BER_CLASS_CON, 203, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_OtherInformation }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_SearchRequest(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + SearchRequest_sequence, hf_index, ett_z3950_SearchRequest); + + return offset; +} + + +static const value_string z3950_T_search_resultSetStatus_vals[] = { + { 1, "subset" }, + { 2, "interim" }, + { 3, "none" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_search_resultSetStatus(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const value_string z3950_PresentStatus_U_vals[] = { + { 0, "success" }, + { 1, "partial-1" }, + { 2, "partial-2" }, + { 3, "partial-3" }, + { 4, "partial-4" }, + { 5, "failure" }, + { 0, NULL } +}; + + +static int +dissect_z3950_PresentStatus_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + + +static int +dissect_z3950_PresentStatus(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset, + hf_index, BER_CLASS_CON, 27, TRUE, dissect_z3950_PresentStatus_U); + + return offset; +} + + + +static int +dissect_z3950_T_diagnosticSetId(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { +#line 228 "./asn1/z3950/z3950.cnf" + tvbuff_t *oid_tvb=NULL; + + + offset = dissect_ber_object_identifier(implicit_tag, actx, tree, tvb, offset, hf_index, &oid_tvb); + +#line 232 "./asn1/z3950/z3950.cnf" + if (oid_tvb) { + guint len = tvb_reported_length_remaining(oid_tvb, 0); + gchar *oid_str = oid_encoded2string(wmem_packet_scope(), + tvb_get_ptr(oid_tvb, 0, len), len); + gint diagset_idx = Z3950_DIAGSET_UNKNOWN; + z3950_diaginfo_t *diaginfo_data; + packet_info *pinfo = actx->pinfo; + + if (g_strcmp0(oid_str, Z3950_DIAGSET_BIB1_OID) == 0) { + diagset_idx = Z3950_DIAGSET_BIB1; + } + if ((diaginfo_data = (z3950_diaginfo_t *)p_get_proto_data(pinfo->pool, pinfo, proto_z3950, Z3950_DIAGSET_KEY)) == NULL) { + + diaginfo_data = wmem_new0(pinfo->pool, z3950_diaginfo_t); + diaginfo_data->diagsetidx = diagset_idx; + p_add_proto_data(pinfo->pool, pinfo, + proto_z3950, Z3950_DIAGSET_KEY, diaginfo_data); + } + else { + diaginfo_data->diagsetidx = diagset_idx; + } + } + + + return offset; +} + + + +static int +dissect_z3950_T_condition(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { +#line 256 "./asn1/z3950/z3950.cnf" + gint diag_condition=0; + packet_info *pinfo = actx->pinfo; + z3950_diaginfo_t *diaginfo_data; + + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + &diag_condition); + +#line 261 "./asn1/z3950/z3950.cnf" + diaginfo_data = (z3950_diaginfo_t *)p_get_proto_data(pinfo->pool, pinfo, proto_z3950, Z3950_DIAGSET_KEY); + if (diaginfo_data && diaginfo_data->diagsetidx == Z3950_DIAGSET_BIB1) { + proto_item_append_text(actx->created_item, " (%s)", + val_to_str(diag_condition, z3950_bib1_diagconditions, "Unknown bib-1 diagnostic %d")); + diaginfo_data->diagcondition = diag_condition; + } + + return offset; +} + + +static const value_string z3950_T_addinfo_vals[] = { + { 0, "v2Addinfo" }, + { 1, "v3Addinfo" }, + { 0, NULL } +}; + +static const ber_choice_t T_addinfo_choice[] = { + { 0, &hf_z3950_v2Addinfo , BER_CLASS_UNI, BER_UNI_TAG_VisibleString, BER_FLAGS_NOOWNTAG, dissect_z3950_VisibleString }, + { 1, &hf_z3950_v3Addinfo , BER_CLASS_UNI, BER_UNI_TAG_GeneralString, BER_FLAGS_NOOWNTAG, dissect_z3950_InternationalString }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_addinfo(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_addinfo_choice, hf_index, ett_z3950_T_addinfo, + NULL); + + return offset; +} + + +static const ber_sequence_t DefaultDiagFormat_sequence[] = { + { &hf_z3950_diagnosticSetId, BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_z3950_T_diagnosticSetId }, + { &hf_z3950_condition , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_z3950_T_condition }, + { &hf_z3950_addinfo , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_T_addinfo }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_DefaultDiagFormat(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + DefaultDiagFormat_sequence, hf_index, ett_z3950_DefaultDiagFormat); + + return offset; +} + + +static const value_string z3950_DiagRec_vals[] = { + { 0, "defaultFormat" }, + { 1, "externallyDefined" }, + { 0, NULL } +}; + +static const ber_choice_t DiagRec_choice[] = { + { 0, &hf_z3950_defaultFormat , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_DefaultDiagFormat }, + { 1, &hf_z3950_externallyDefined, BER_CLASS_UNI, BER_UNI_TAG_EXTERNAL, BER_FLAGS_NOOWNTAG, dissect_z3950_EXTERNAL }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_DiagRec(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + DiagRec_choice, hf_index, ett_z3950_DiagRec, + NULL); + + return offset; +} + + +static const value_string z3950_FragmentSyntax_vals[] = { + { 0, "externallyTagged" }, + { 1, "notExternallyTagged" }, + { 0, NULL } +}; + +static const ber_choice_t FragmentSyntax_choice[] = { + { 0, &hf_z3950_externallyTagged, BER_CLASS_UNI, BER_UNI_TAG_EXTERNAL, BER_FLAGS_NOOWNTAG, dissect_z3950_EXTERNAL }, + { 1, &hf_z3950_notExternallyTagged, BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_z3950_OCTET_STRING }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_FragmentSyntax(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + FragmentSyntax_choice, hf_index, ett_z3950_FragmentSyntax, + NULL); + + return offset; +} + + +static const value_string z3950_T_record_vals[] = { + { 1, "retrievalRecord" }, + { 2, "surrogateDiagnostic" }, + { 3, "startingFragment" }, + { 4, "intermediateFragment" }, + { 5, "finalFragment" }, + { 0, NULL } +}; + +static const ber_choice_t T_record_choice[] = { + { 1, &hf_z3950_retrievalRecord, BER_CLASS_CON, 1, 0, dissect_z3950_EXTERNAL }, + { 2, &hf_z3950_surrogateDiagnostic, BER_CLASS_CON, 2, 0, dissect_z3950_DiagRec }, + { 3, &hf_z3950_startingFragment, BER_CLASS_CON, 3, 0, dissect_z3950_FragmentSyntax }, + { 4, &hf_z3950_intermediateFragment, BER_CLASS_CON, 4, 0, dissect_z3950_FragmentSyntax }, + { 5, &hf_z3950_finalFragment , BER_CLASS_CON, 5, 0, dissect_z3950_FragmentSyntax }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_record(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_record_choice, hf_index, ett_z3950_T_record, + NULL); + + return offset; +} + + +static const ber_sequence_t NamePlusRecord_sequence[] = { + { &hf_z3950_namePlusRecord_name, BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_DatabaseName }, + { &hf_z3950_record , BER_CLASS_CON, 1, 0, dissect_z3950_T_record }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_NamePlusRecord(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + NamePlusRecord_sequence, hf_index, ett_z3950_NamePlusRecord); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_NamePlusRecord_sequence_of[1] = { + { &hf_z3950_segmentRecords_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_NamePlusRecord }, +}; + +static int +dissect_z3950_SEQUENCE_OF_NamePlusRecord(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_NamePlusRecord_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_NamePlusRecord); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_DiagRec_sequence_of[1] = { + { &hf_z3950_multipleNonSurDiagnostics_item, BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_DiagRec }, +}; + +static int +dissect_z3950_SEQUENCE_OF_DiagRec(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_DiagRec_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_DiagRec); + + return offset; +} + + +static const value_string z3950_Records_vals[] = { + { 28, "responseRecords" }, + { 130, "nonSurrogateDiagnostic" }, + { 205, "multipleNonSurDiagnostics" }, + { 0, NULL } +}; + +static const ber_choice_t Records_choice[] = { + { 28, &hf_z3950_responseRecords, BER_CLASS_CON, 28, BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_NamePlusRecord }, + { 130, &hf_z3950_nonSurrogateDiagnostic, BER_CLASS_CON, 130, BER_FLAGS_IMPLTAG, dissect_z3950_DefaultDiagFormat }, + { 205, &hf_z3950_multipleNonSurDiagnostics, BER_CLASS_CON, 205, BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_DiagRec }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Records(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + Records_choice, hf_index, ett_z3950_Records, + NULL); + + return offset; +} + + +static const ber_sequence_t SearchResponse_sequence[] = { + { &hf_z3950_referenceId , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_resultCount , BER_CLASS_CON, 23, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_numberOfRecordsReturned, BER_CLASS_CON, 24, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_nextResultSetPosition, BER_CLASS_CON, 25, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_searchStatus , BER_CLASS_CON, 22, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_search_resultSetStatus, BER_CLASS_CON, 26, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_search_resultSetStatus }, + { &hf_z3950_presentStatus , BER_CLASS_CON, 27, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_PresentStatus }, + { &hf_z3950_records , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_Records }, + { &hf_z3950_additionalSearchInfo, BER_CLASS_CON, 203, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_OtherInformation }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_SearchResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + SearchResponse_sequence, hf_index, ett_z3950_SearchResponse); + + return offset; +} + + +static const ber_sequence_t Range_sequence[] = { + { &hf_z3950_startingPosition, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_numberOfRecords, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Range(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + Range_sequence, hf_index, ett_z3950_Range); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_Range_sequence_of[1] = { + { &hf_z3950_additionalRanges_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_Range }, +}; + +static int +dissect_z3950_SEQUENCE_OF_Range(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_Range_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_Range); + + return offset; +} + + +static const value_string z3950_T_specification_elementSpec_vals[] = { + { 1, "elementSetName" }, + { 2, "externalEspec" }, + { 0, NULL } +}; + +static const ber_choice_t T_specification_elementSpec_choice[] = { + { 1, &hf_z3950_elementSetName, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { 2, &hf_z3950_externalEspec , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_EXTERNAL }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_specification_elementSpec(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_specification_elementSpec_choice, hf_index, ett_z3950_T_specification_elementSpec, + NULL); + + return offset; +} + + +static const ber_sequence_t Specification_sequence[] = { + { &hf_z3950_schema , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { &hf_z3950_specification_elementSpec, BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL, dissect_z3950_T_specification_elementSpec }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Specification(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + Specification_sequence, hf_index, ett_z3950_Specification); + + return offset; +} + + +static const ber_sequence_t T_dbSpecific_item_sequence[] = { + { &hf_z3950_db , BER_CLASS_CON, 1, 0, dissect_z3950_DatabaseName }, + { &hf_z3950_spec , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_Specification }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_dbSpecific_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_dbSpecific_item_sequence, hf_index, ett_z3950_T_dbSpecific_item); + + return offset; +} + + +static const ber_sequence_t T_dbSpecific_sequence_of[1] = { + { &hf_z3950_dbSpecific_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_T_dbSpecific_item }, +}; + +static int +dissect_z3950_T_dbSpecific(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_dbSpecific_sequence_of, hf_index, ett_z3950_T_dbSpecific); + + return offset; +} + + +static const ber_sequence_t T_compSpec_recordSyntax_sequence_of[1] = { + { &hf_z3950_compSpec_recordSyntax_item, BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_z3950_OBJECT_IDENTIFIER }, +}; + +static int +dissect_z3950_T_compSpec_recordSyntax(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_compSpec_recordSyntax_sequence_of, hf_index, ett_z3950_T_compSpec_recordSyntax); + + return offset; +} + + +static const ber_sequence_t CompSpec_sequence[] = { + { &hf_z3950_selectAlternativeSyntax, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_compSpec_generic, BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_Specification }, + { &hf_z3950_dbSpecific , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_dbSpecific }, + { &hf_z3950_compSpec_recordSyntax, BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_compSpec_recordSyntax }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_CompSpec(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + CompSpec_sequence, hf_index, ett_z3950_CompSpec); + + return offset; +} + + +static const value_string z3950_T_recordComposition_vals[] = { + { 19, "simple" }, + { 209, "complex" }, + { 0, NULL } +}; + +static const ber_choice_t T_recordComposition_choice[] = { + { 19, &hf_z3950_simple , BER_CLASS_CON, 19, 0, dissect_z3950_ElementSetNames }, + { 209, &hf_z3950_recordComposition_complex, BER_CLASS_CON, 209, BER_FLAGS_IMPLTAG, dissect_z3950_CompSpec }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_recordComposition(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_recordComposition_choice, hf_index, ett_z3950_T_recordComposition, + NULL); + + return offset; +} + + +static const ber_sequence_t PresentRequest_sequence[] = { + { &hf_z3950_referenceId , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_resultSetId , BER_CLASS_CON, 31, BER_FLAGS_NOOWNTAG, dissect_z3950_ResultSetId }, + { &hf_z3950_resultSetStartPoint, BER_CLASS_CON, 30, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_numberOfRecordsRequested, BER_CLASS_CON, 29, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_additionalRanges, BER_CLASS_CON, 212, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_Range }, + { &hf_z3950_recordComposition, BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_T_recordComposition }, + { &hf_z3950_preferredRecordSyntax, BER_CLASS_CON, 104, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { &hf_z3950_maxSegmentCount, BER_CLASS_CON, 204, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_maxRecordSize , BER_CLASS_CON, 206, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_maxSegmentSize, BER_CLASS_CON, 207, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_PresentRequest(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + PresentRequest_sequence, hf_index, ett_z3950_PresentRequest); + + return offset; +} + + +static const ber_sequence_t PresentResponse_sequence[] = { + { &hf_z3950_referenceId , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_numberOfRecordsReturned, BER_CLASS_CON, 24, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_nextResultSetPosition, BER_CLASS_CON, 25, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_presentStatus , BER_CLASS_CON, 27, BER_FLAGS_NOOWNTAG, dissect_z3950_PresentStatus }, + { &hf_z3950_records , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_Records }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_PresentResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + PresentResponse_sequence, hf_index, ett_z3950_PresentResponse); + + return offset; +} + + +static const value_string z3950_T_deleteFunction_vals[] = { + { 0, "list" }, + { 1, "all" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_deleteFunction(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_ResultSetId_sequence_of[1] = { + { &hf_z3950_resultSetList_item, BER_CLASS_CON, 31, BER_FLAGS_NOOWNTAG, dissect_z3950_ResultSetId }, +}; + +static int +dissect_z3950_SEQUENCE_OF_ResultSetId(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_ResultSetId_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_ResultSetId); + + return offset; +} + + +static const ber_sequence_t DeleteResultSetRequest_sequence[] = { + { &hf_z3950_referenceId , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_deleteFunction, BER_CLASS_CON, 32, BER_FLAGS_IMPLTAG, dissect_z3950_T_deleteFunction }, + { &hf_z3950_resultSetList , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_SEQUENCE_OF_ResultSetId }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_DeleteResultSetRequest(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + DeleteResultSetRequest_sequence, hf_index, ett_z3950_DeleteResultSetRequest); + + return offset; +} + + +static const value_string z3950_DeleteSetStatus_U_vals[] = { + { 0, "success" }, + { 1, "resultSetDidNotExist" }, + { 2, "previouslyDeletedByTarget" }, + { 3, "systemProblemAtTarget" }, + { 4, "accessNotAllowed" }, + { 5, "resourceControlAtOrigin" }, + { 6, "resourceControlAtTarget" }, + { 7, "bulkDeleteNotSupported" }, + { 8, "notAllRsltSetsDeletedOnBulkDlte" }, + { 9, "notAllRequestedResultSetsDeleted" }, + { 10, "resultSetInUse" }, + { 0, NULL } +}; + + +static int +dissect_z3950_DeleteSetStatus_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + + +static int +dissect_z3950_DeleteSetStatus(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset, + hf_index, BER_CLASS_CON, 33, TRUE, dissect_z3950_DeleteSetStatus_U); + + return offset; +} + + +static const ber_sequence_t ListStatuses_item_sequence[] = { + { &hf_z3950_listStatuses_id, BER_CLASS_CON, 31, BER_FLAGS_NOOWNTAG, dissect_z3950_ResultSetId }, + { &hf_z3950_status , BER_CLASS_CON, 33, BER_FLAGS_NOOWNTAG, dissect_z3950_DeleteSetStatus }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ListStatuses_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + ListStatuses_item_sequence, hf_index, ett_z3950_ListStatuses_item); + + return offset; +} + + +static const ber_sequence_t ListStatuses_sequence_of[1] = { + { &hf_z3950_ListStatuses_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_ListStatuses_item }, +}; + +static int +dissect_z3950_ListStatuses(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + ListStatuses_sequence_of, hf_index, ett_z3950_ListStatuses); + + return offset; +} + + +static const ber_sequence_t DeleteResultSetResponse_sequence[] = { + { &hf_z3950_referenceId , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_deleteOperationStatus, BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_DeleteSetStatus }, + { &hf_z3950_deleteListStatuses, BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_ListStatuses }, + { &hf_z3950_numberNotDeleted, BER_CLASS_CON, 34, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_bulkStatuses , BER_CLASS_CON, 35, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_ListStatuses }, + { &hf_z3950_deleteMessage , BER_CLASS_CON, 36, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_DeleteResultSetResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + DeleteResultSetResponse_sequence, hf_index, ett_z3950_DeleteResultSetResponse); + + return offset; +} + + +static const value_string z3950_T_securityChallenge_vals[] = { + { 37, "simpleForm" }, + { 0, "externallyDefined" }, + { 0, NULL } +}; + +static const ber_choice_t T_securityChallenge_choice[] = { + { 37, &hf_z3950_simpleForm , BER_CLASS_CON, 37, BER_FLAGS_IMPLTAG, dissect_z3950_OCTET_STRING }, + { 0, &hf_z3950_externallyDefined, BER_CLASS_CON, 0, 0, dissect_z3950_EXTERNAL }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_securityChallenge(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_securityChallenge_choice, hf_index, ett_z3950_T_securityChallenge, + NULL); + + return offset; +} + + +static const ber_sequence_t AccessControlRequest_sequence[] = { + { &hf_z3950_referenceId , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_securityChallenge, BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_T_securityChallenge }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_AccessControlRequest(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + AccessControlRequest_sequence, hf_index, ett_z3950_AccessControlRequest); + + return offset; +} + + +static const value_string z3950_T_securityChallengeResponse_vals[] = { + { 38, "simpleForm" }, + { 0, "externallyDefined" }, + { 0, NULL } +}; + +static const ber_choice_t T_securityChallengeResponse_choice[] = { + { 38, &hf_z3950_simpleForm , BER_CLASS_CON, 38, BER_FLAGS_IMPLTAG, dissect_z3950_OCTET_STRING }, + { 0, &hf_z3950_externallyDefined, BER_CLASS_CON, 0, 0, dissect_z3950_EXTERNAL }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_securityChallengeResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_securityChallengeResponse_choice, hf_index, ett_z3950_T_securityChallengeResponse, + NULL); + + return offset; +} + + +static const ber_sequence_t AccessControlResponse_sequence[] = { + { &hf_z3950_referenceId , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_securityChallengeResponse, BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_T_securityChallengeResponse }, + { &hf_z3950_diagnostic , BER_CLASS_CON, 223, BER_FLAGS_OPTIONAL|BER_FLAGS_NOTCHKTAG, dissect_z3950_DiagRec }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_AccessControlResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + AccessControlResponse_sequence, hf_index, ett_z3950_AccessControlResponse); + + return offset; +} + + + +static int +dissect_z3950_ResourceReport(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_external_type(implicit_tag, tree, tvb, offset, actx, hf_index, NULL); + + return offset; +} + + +static const value_string z3950_T_partialResultsAvailable_vals[] = { + { 1, "subset" }, + { 2, "interim" }, + { 3, "none" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_partialResultsAvailable(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const ber_sequence_t ResourceControlRequest_sequence[] = { + { &hf_z3950_referenceId , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_suspendedFlag , BER_CLASS_CON, 39, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_resourceReport, BER_CLASS_CON, 40, BER_FLAGS_OPTIONAL, dissect_z3950_ResourceReport }, + { &hf_z3950_partialResultsAvailable, BER_CLASS_CON, 41, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_partialResultsAvailable }, + { &hf_z3950_resourceControlRequest_responseRequired, BER_CLASS_CON, 42, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_triggeredRequestFlag, BER_CLASS_CON, 43, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ResourceControlRequest(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + ResourceControlRequest_sequence, hf_index, ett_z3950_ResourceControlRequest); + + return offset; +} + + +static const ber_sequence_t ResourceControlResponse_sequence[] = { + { &hf_z3950_referenceId , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_continueFlag , BER_CLASS_CON, 44, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_resultSetWanted, BER_CLASS_CON, 45, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ResourceControlResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + ResourceControlResponse_sequence, hf_index, ett_z3950_ResourceControlResponse); + + return offset; +} + + +static const value_string z3950_T_requestedAction_vals[] = { + { 1, "resourceReport" }, + { 2, "resourceControl" }, + { 3, "cancel" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_requestedAction(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + + +static int +dissect_z3950_ResourceReportId(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_object_identifier(implicit_tag, actx, tree, tvb, offset, hf_index, NULL); + + return offset; +} + + +static const ber_sequence_t TriggerResourceControlRequest_sequence[] = { + { &hf_z3950_referenceId , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_requestedAction, BER_CLASS_CON, 46, BER_FLAGS_IMPLTAG, dissect_z3950_T_requestedAction }, + { &hf_z3950_prefResourceReportFormat, BER_CLASS_CON, 47, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_ResourceReportId }, + { &hf_z3950_resultSetWanted, BER_CLASS_CON, 48, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_TriggerResourceControlRequest(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + TriggerResourceControlRequest_sequence, hf_index, ett_z3950_TriggerResourceControlRequest); + + return offset; +} + + +static const ber_sequence_t ResourceReportRequest_sequence[] = { + { &hf_z3950_referenceId , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_opId , BER_CLASS_CON, 210, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_prefResourceReportFormat, BER_CLASS_CON, 49, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_ResourceReportId }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ResourceReportRequest(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + ResourceReportRequest_sequence, hf_index, ett_z3950_ResourceReportRequest); + + return offset; +} + + +static const value_string z3950_T_resourceReportStatus_vals[] = { + { 0, "success" }, + { 1, "partial" }, + { 2, "failure-1" }, + { 3, "failure-2" }, + { 4, "failure-3" }, + { 5, "failure-4" }, + { 6, "failure-5" }, + { 7, "failure-6" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_resourceReportStatus(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const ber_sequence_t ResourceReportResponse_sequence[] = { + { &hf_z3950_referenceId , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_resourceReportStatus, BER_CLASS_CON, 50, BER_FLAGS_IMPLTAG, dissect_z3950_T_resourceReportStatus }, + { &hf_z3950_resourceReport, BER_CLASS_CON, 51, BER_FLAGS_OPTIONAL, dissect_z3950_ResourceReport }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ResourceReportResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + ResourceReportResponse_sequence, hf_index, ett_z3950_ResourceReportResponse); + + return offset; +} + + +static const ber_sequence_t ScanRequest_sequence[] = { + { &hf_z3950_referenceId , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_databaseNames , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_DatabaseName }, + { &hf_z3950_attributeSet , BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_AttributeSetId }, + { &hf_z3950_termListAndStartPoint, BER_CLASS_CON, 102, BER_FLAGS_NOOWNTAG, dissect_z3950_AttributesPlusTerm }, + { &hf_z3950_stepSize , BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_numberOfTermsRequested, BER_CLASS_CON, 6, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_preferredPositionInResponse, BER_CLASS_CON, 7, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ScanRequest(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + ScanRequest_sequence, hf_index, ett_z3950_ScanRequest); + + return offset; +} + + +static const value_string z3950_T_scanStatus_vals[] = { + { 0, "success" }, + { 1, "partial-1" }, + { 2, "partial-2" }, + { 3, "partial-3" }, + { 4, "partial-4" }, + { 5, "partial-5" }, + { 6, "failure" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_scanStatus(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_AttributesPlusTerm_sequence_of[1] = { + { &hf_z3950_alternativeTerm_item, BER_CLASS_CON, 102, BER_FLAGS_NOOWNTAG, dissect_z3950_AttributesPlusTerm }, +}; + +static int +dissect_z3950_SEQUENCE_OF_AttributesPlusTerm(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_AttributesPlusTerm_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_AttributesPlusTerm); + + return offset; +} + + +static const ber_sequence_t T_byDatabase_item_sequence[] = { + { &hf_z3950_db , BER_CLASS_CON, 105, BER_FLAGS_NOOWNTAG, dissect_z3950_DatabaseName }, + { &hf_z3950_num , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_otherDbInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_byDatabase_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_byDatabase_item_sequence, hf_index, ett_z3950_T_byDatabase_item); + + return offset; +} + + +static const ber_sequence_t T_byDatabase_sequence_of[1] = { + { &hf_z3950_byDatabase_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_T_byDatabase_item }, +}; + +static int +dissect_z3950_T_byDatabase(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_byDatabase_sequence_of, hf_index, ett_z3950_T_byDatabase); + + return offset; +} + + +static const value_string z3950_T_occurrences_vals[] = { + { 2, "global" }, + { 3, "byDatabase" }, + { 0, NULL } +}; + +static const ber_choice_t T_occurrences_choice[] = { + { 2, &hf_z3950_global , BER_CLASS_CON, 2, 0, dissect_z3950_INTEGER }, + { 3, &hf_z3950_byDatabase , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_T_byDatabase }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_occurrences(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_occurrences_choice, hf_index, ett_z3950_T_occurrences, + NULL); + + return offset; +} + + +static const ber_sequence_t OccurrenceByAttributes_item_sequence[] = { + { &hf_z3950_attributes , BER_CLASS_CON, 1, 0, dissect_z3950_AttributeList }, + { &hf_z3950_occurrences , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_T_occurrences }, + { &hf_z3950_otherOccurInfo, BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_OccurrenceByAttributes_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + OccurrenceByAttributes_item_sequence, hf_index, ett_z3950_OccurrenceByAttributes_item); + + return offset; +} + + +static const ber_sequence_t OccurrenceByAttributes_sequence_of[1] = { + { &hf_z3950_OccurrenceByAttributes_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_OccurrenceByAttributes_item }, +}; + +static int +dissect_z3950_OccurrenceByAttributes(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + OccurrenceByAttributes_sequence_of, hf_index, ett_z3950_OccurrenceByAttributes); + + return offset; +} + + +static const ber_sequence_t TermInfo_sequence[] = { + { &hf_z3950_term , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_Term }, + { &hf_z3950_displayTerm , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_suggestedAttributes, BER_CLASS_CON, 44, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_AttributeList }, + { &hf_z3950_alternativeTerm, BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_AttributesPlusTerm }, + { &hf_z3950_globalOccurrences, BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_byAttributes , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_OccurrenceByAttributes }, + { &hf_z3950_otherTermInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_TermInfo(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + TermInfo_sequence, hf_index, ett_z3950_TermInfo); + + return offset; +} + + +static const value_string z3950_Entry_vals[] = { + { 1, "termInfo" }, + { 2, "surrogateDiagnostic" }, + { 0, NULL } +}; + +static const ber_choice_t Entry_choice[] = { + { 1, &hf_z3950_termInfo , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_TermInfo }, + { 2, &hf_z3950_surrogateDiagnostic, BER_CLASS_CON, 2, 0, dissect_z3950_DiagRec }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Entry(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + Entry_choice, hf_index, ett_z3950_Entry, + NULL); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_Entry_sequence_of[1] = { + { &hf_z3950_listEntries_entries_item, BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_Entry }, +}; + +static int +dissect_z3950_SEQUENCE_OF_Entry(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_Entry_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_Entry); + + return offset; +} + + +static const ber_sequence_t ListEntries_sequence[] = { + { &hf_z3950_listEntries_entries, BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_Entry }, + { &hf_z3950_nonsurrogateDiagnostics, BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_DiagRec }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ListEntries(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + ListEntries_sequence, hf_index, ett_z3950_ListEntries); + + return offset; +} + + +static const ber_sequence_t ScanResponse_sequence[] = { + { &hf_z3950_referenceId , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_stepSize , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_scanStatus , BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_z3950_T_scanStatus }, + { &hf_z3950_numberOfEntriesReturned, BER_CLASS_CON, 5, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_positionOfTerm, BER_CLASS_CON, 6, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_scanResponse_entries, BER_CLASS_CON, 7, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_ListEntries }, + { &hf_z3950_attributeSet , BER_CLASS_CON, 8, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_AttributeSetId }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ScanResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + ScanResponse_sequence, hf_index, ett_z3950_ScanResponse); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_InternationalString_sequence_of[1] = { + { &hf_z3950_inputResultSetNames_item, BER_CLASS_UNI, BER_UNI_TAG_GeneralString, BER_FLAGS_NOOWNTAG, dissect_z3950_InternationalString }, +}; + +static int +dissect_z3950_SEQUENCE_OF_InternationalString(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_InternationalString_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_InternationalString); + + return offset; +} + + +static const ber_sequence_t T_sortAttributes_sequence[] = { + { &hf_z3950_sortAttributes_id, BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_z3950_AttributeSetId }, + { &hf_z3950_sortAttributes_list, BER_CLASS_CON, 44, BER_FLAGS_NOOWNTAG, dissect_z3950_AttributeList }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_sortAttributes(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_sortAttributes_sequence, hf_index, ett_z3950_T_sortAttributes); + + return offset; +} + + +static const value_string z3950_SortKey_vals[] = { + { 0, "sortfield" }, + { 1, "elementSpec" }, + { 2, "sortAttributes" }, + { 0, NULL } +}; + +static const ber_choice_t SortKey_choice[] = { + { 0, &hf_z3950_sortfield , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { 1, &hf_z3950_sortKey_elementSpec, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_Specification }, + { 2, &hf_z3950_sortAttributes, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_T_sortAttributes }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_SortKey(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + SortKey_choice, hf_index, ett_z3950_SortKey, + NULL); + + return offset; +} + + +static const ber_sequence_t T_datbaseSpecific_item_sequence[] = { + { &hf_z3950_databaseName , BER_CLASS_CON, 105, BER_FLAGS_NOOWNTAG, dissect_z3950_DatabaseName }, + { &hf_z3950_dbSort , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_SortKey }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_datbaseSpecific_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_datbaseSpecific_item_sequence, hf_index, ett_z3950_T_datbaseSpecific_item); + + return offset; +} + + +static const ber_sequence_t T_datbaseSpecific_sequence_of[1] = { + { &hf_z3950_datbaseSpecific_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_T_datbaseSpecific_item }, +}; + +static int +dissect_z3950_T_datbaseSpecific(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_datbaseSpecific_sequence_of, hf_index, ett_z3950_T_datbaseSpecific); + + return offset; +} + + +static const value_string z3950_SortElement_vals[] = { + { 1, "generic" }, + { 2, "datbaseSpecific" }, + { 0, NULL } +}; + +static const ber_choice_t SortElement_choice[] = { + { 1, &hf_z3950_sortElement_generic, BER_CLASS_CON, 1, 0, dissect_z3950_SortKey }, + { 2, &hf_z3950_datbaseSpecific, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_T_datbaseSpecific }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_SortElement(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + SortElement_choice, hf_index, ett_z3950_SortElement, + NULL); + + return offset; +} + + +static const value_string z3950_T_sortRelation_vals[] = { + { 0, "ascending" }, + { 1, "descending" }, + { 3, "ascendingByFrequency" }, + { 4, "descendingByfrequency" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_sortRelation(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const value_string z3950_T_caseSensitivity_vals[] = { + { 0, "caseSensitive" }, + { 1, "caseInsensitive" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_caseSensitivity(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const value_string z3950_T_missingValueAction_vals[] = { + { 1, "abort" }, + { 2, "null" }, + { 3, "missingValueData" }, + { 0, NULL } +}; + +static const ber_choice_t T_missingValueAction_choice[] = { + { 1, &hf_z3950_abort , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 2, &hf_z3950_null , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 3, &hf_z3950_missingValueData, BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_OCTET_STRING }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_missingValueAction(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_missingValueAction_choice, hf_index, ett_z3950_T_missingValueAction, + NULL); + + return offset; +} + + +static const ber_sequence_t SortKeySpec_sequence[] = { + { &hf_z3950_sortElement , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_SortElement }, + { &hf_z3950_sortRelation , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_T_sortRelation }, + { &hf_z3950_caseSensitivity, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_T_caseSensitivity }, + { &hf_z3950_missingValueAction, BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL, dissect_z3950_T_missingValueAction }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_SortKeySpec(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + SortKeySpec_sequence, hf_index, ett_z3950_SortKeySpec); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_SortKeySpec_sequence_of[1] = { + { &hf_z3950_sortSequence_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_SortKeySpec }, +}; + +static int +dissect_z3950_SEQUENCE_OF_SortKeySpec(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_SortKeySpec_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_SortKeySpec); + + return offset; +} + + +static const ber_sequence_t SortRequest_sequence[] = { + { &hf_z3950_referenceId , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_inputResultSetNames, BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_InternationalString }, + { &hf_z3950_sortedResultSetName, BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_sortSequence , BER_CLASS_CON, 5, BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_SortKeySpec }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_SortRequest(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + SortRequest_sequence, hf_index, ett_z3950_SortRequest); + + return offset; +} + + +static const value_string z3950_T_sortStatus_vals[] = { + { 0, "success" }, + { 1, "partial-1" }, + { 2, "failure" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_sortStatus(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const value_string z3950_T_sort_resultSetStatus_vals[] = { + { 1, "empty" }, + { 2, "interim" }, + { 3, "unchanged" }, + { 4, "none" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_sort_resultSetStatus(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const ber_sequence_t SortResponse_sequence[] = { + { &hf_z3950_referenceId , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_sortStatus , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_T_sortStatus }, + { &hf_z3950_sort_resultSetStatus, BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_sort_resultSetStatus }, + { &hf_z3950_diagnostics , BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_DiagRec }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_SortResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + SortResponse_sequence, hf_index, ett_z3950_SortResponse); + + return offset; +} + + +static const ber_sequence_t Segment_sequence[] = { + { &hf_z3950_referenceId , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_numberOfRecordsReturned, BER_CLASS_CON, 24, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_segmentRecords, BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_NamePlusRecord }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Segment(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + Segment_sequence, hf_index, ett_z3950_Segment); + + return offset; +} + + +static const value_string z3950_T_function_vals[] = { + { 1, "create" }, + { 2, "delete" }, + { 3, "modify" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_function(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const value_string z3950_T_allowableFunctions_item_vals[] = { + { 1, "delete" }, + { 2, "modifyContents" }, + { 3, "modifyPermissions" }, + { 4, "present" }, + { 5, "invoke" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_allowableFunctions_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const ber_sequence_t T_allowableFunctions_sequence_of[1] = { + { &hf_z3950_allowableFunctions_item, BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_z3950_T_allowableFunctions_item }, +}; + +static int +dissect_z3950_T_allowableFunctions(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_allowableFunctions_sequence_of, hf_index, ett_z3950_T_allowableFunctions); + + return offset; +} + + +static const ber_sequence_t Permissions_item_sequence[] = { + { &hf_z3950_userId , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_allowableFunctions, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_T_allowableFunctions }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Permissions_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + Permissions_item_sequence, hf_index, ett_z3950_Permissions_item); + + return offset; +} + + +static const ber_sequence_t Permissions_sequence_of[1] = { + { &hf_z3950_Permissions_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_Permissions_item }, +}; + +static int +dissect_z3950_Permissions(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + Permissions_sequence_of, hf_index, ett_z3950_Permissions); + + return offset; +} + + +static const value_string z3950_T_waitAction_vals[] = { + { 1, "wait" }, + { 2, "waitIfPossible" }, + { 3, "dontWait" }, + { 4, "dontReturnPackage" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_waitAction(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const ber_sequence_t ExtendedServicesRequest_sequence[] = { + { &hf_z3950_referenceId , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_function , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_T_function }, + { &hf_z3950_packageType , BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { &hf_z3950_packageName , BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_userId , BER_CLASS_CON, 6, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_retentionTime , BER_CLASS_CON, 7, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_IntUnit }, + { &hf_z3950_permissions , BER_CLASS_CON, 8, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_Permissions }, + { &hf_z3950_extendedServicesRequest_description, BER_CLASS_CON, 9, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_taskSpecificParameters, BER_CLASS_CON, 10, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_EXTERNAL }, + { &hf_z3950_waitAction , BER_CLASS_CON, 11, BER_FLAGS_IMPLTAG, dissect_z3950_T_waitAction }, + { &hf_z3950_elements , BER_CLASS_CON, 103, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ElementSetName }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ExtendedServicesRequest(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + ExtendedServicesRequest_sequence, hf_index, ett_z3950_ExtendedServicesRequest); + + return offset; +} + + +static const value_string z3950_T_operationStatus_vals[] = { + { 1, "done" }, + { 2, "accepted" }, + { 3, "failure" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_operationStatus(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const ber_sequence_t ExtendedServicesResponse_sequence[] = { + { &hf_z3950_referenceId , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_operationStatus, BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_T_operationStatus }, + { &hf_z3950_diagnostics , BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_DiagRec }, + { &hf_z3950_taskPackage , BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_EXTERNAL }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ExtendedServicesResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + ExtendedServicesResponse_sequence, hf_index, ett_z3950_ExtendedServicesResponse); + + return offset; +} + + +static const value_string z3950_CloseReason_U_vals[] = { + { 0, "finished" }, + { 1, "shutdown" }, + { 2, "systemProblem" }, + { 3, "costLimit" }, + { 4, "resources" }, + { 5, "securityViolation" }, + { 6, "protocolError" }, + { 7, "lackOfActivity" }, + { 8, "peerAbort" }, + { 9, "unspecified" }, + { 0, NULL } +}; + + +static int +dissect_z3950_CloseReason_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + + +static int +dissect_z3950_CloseReason(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset, + hf_index, BER_CLASS_CON, 211, TRUE, dissect_z3950_CloseReason_U); + + return offset; +} + + +static const ber_sequence_t Close_sequence[] = { + { &hf_z3950_referenceId , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_ReferenceId }, + { &hf_z3950_closeReason , BER_CLASS_CON, 211, BER_FLAGS_NOOWNTAG, dissect_z3950_CloseReason }, + { &hf_z3950_diagnosticInformation, BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_resourceReportFormat, BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_ResourceReportId }, + { &hf_z3950_resourceReport, BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL, dissect_z3950_ResourceReport }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Close(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + Close_sequence, hf_index, ett_z3950_Close); + + return offset; +} + + +static const value_string z3950_PDU_vals[] = { + { 20, "initRequest" }, + { 21, "initResponse" }, + { 22, "searchRequest" }, + { 23, "searchResponse" }, + { 24, "presentRequest" }, + { 25, "presentResponse" }, + { 26, "deleteResultSetRequest" }, + { 27, "deleteResultSetResponse" }, + { 28, "accessControlRequest" }, + { 29, "accessControlResponse" }, + { 30, "resourceControlRequest" }, + { 31, "resourceControlResponse" }, + { 32, "triggerResourceControlRequest" }, + { 33, "resourceReportRequest" }, + { 34, "resourceReportResponse" }, + { 35, "scanRequest" }, + { 36, "scanResponse" }, + { 43, "sortRequest" }, + { 44, "sortResponse" }, + { 45, "segmentRequest" }, + { 46, "extendedServicesRequest" }, + { 47, "extendedServicesResponse" }, + { 48, "close" }, + { 0, NULL } +}; + +static const ber_choice_t PDU_choice[] = { + { 20, &hf_z3950_initRequest , BER_CLASS_CON, 20, BER_FLAGS_IMPLTAG, dissect_z3950_InitializeRequest }, + { 21, &hf_z3950_initResponse , BER_CLASS_CON, 21, BER_FLAGS_IMPLTAG, dissect_z3950_InitializeResponse }, + { 22, &hf_z3950_searchRequest , BER_CLASS_CON, 22, BER_FLAGS_IMPLTAG, dissect_z3950_SearchRequest }, + { 23, &hf_z3950_searchResponse, BER_CLASS_CON, 23, BER_FLAGS_IMPLTAG, dissect_z3950_SearchResponse }, + { 24, &hf_z3950_presentRequest, BER_CLASS_CON, 24, BER_FLAGS_IMPLTAG, dissect_z3950_PresentRequest }, + { 25, &hf_z3950_presentResponse, BER_CLASS_CON, 25, BER_FLAGS_IMPLTAG, dissect_z3950_PresentResponse }, + { 26, &hf_z3950_deleteResultSetRequest, BER_CLASS_CON, 26, BER_FLAGS_IMPLTAG, dissect_z3950_DeleteResultSetRequest }, + { 27, &hf_z3950_deleteResultSetResponse, BER_CLASS_CON, 27, BER_FLAGS_IMPLTAG, dissect_z3950_DeleteResultSetResponse }, + { 28, &hf_z3950_accessControlRequest, BER_CLASS_CON, 28, BER_FLAGS_IMPLTAG, dissect_z3950_AccessControlRequest }, + { 29, &hf_z3950_accessControlResponse, BER_CLASS_CON, 29, BER_FLAGS_IMPLTAG, dissect_z3950_AccessControlResponse }, + { 30, &hf_z3950_resourceControlRequest, BER_CLASS_CON, 30, BER_FLAGS_IMPLTAG, dissect_z3950_ResourceControlRequest }, + { 31, &hf_z3950_resourceControlResponse, BER_CLASS_CON, 31, BER_FLAGS_IMPLTAG, dissect_z3950_ResourceControlResponse }, + { 32, &hf_z3950_triggerResourceControlRequest, BER_CLASS_CON, 32, BER_FLAGS_IMPLTAG, dissect_z3950_TriggerResourceControlRequest }, + { 33, &hf_z3950_resourceReportRequest, BER_CLASS_CON, 33, BER_FLAGS_IMPLTAG, dissect_z3950_ResourceReportRequest }, + { 34, &hf_z3950_resourceReportResponse, BER_CLASS_CON, 34, BER_FLAGS_IMPLTAG, dissect_z3950_ResourceReportResponse }, + { 35, &hf_z3950_scanRequest , BER_CLASS_CON, 35, BER_FLAGS_IMPLTAG, dissect_z3950_ScanRequest }, + { 36, &hf_z3950_scanResponse , BER_CLASS_CON, 36, BER_FLAGS_IMPLTAG, dissect_z3950_ScanResponse }, + { 43, &hf_z3950_sortRequest , BER_CLASS_CON, 43, BER_FLAGS_IMPLTAG, dissect_z3950_SortRequest }, + { 44, &hf_z3950_sortResponse , BER_CLASS_CON, 44, BER_FLAGS_IMPLTAG, dissect_z3950_SortResponse }, + { 45, &hf_z3950_segmentRequest, BER_CLASS_CON, 45, BER_FLAGS_IMPLTAG, dissect_z3950_Segment }, + { 46, &hf_z3950_extendedServicesRequest, BER_CLASS_CON, 46, BER_FLAGS_IMPLTAG, dissect_z3950_ExtendedServicesRequest }, + { 47, &hf_z3950_extendedServicesResponse, BER_CLASS_CON, 47, BER_FLAGS_IMPLTAG, dissect_z3950_ExtendedServicesResponse }, + { 48, &hf_z3950_close , BER_CLASS_CON, 48, BER_FLAGS_IMPLTAG, dissect_z3950_Close }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_PDU(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { +#line 127 "./asn1/z3950/z3950.cnf" + gint choice; + + offset = dissect_ber_choice(actx, tree, tvb, offset, + PDU_choice, hf_index, ett_z3950_PDU, + &choice); + +#line 130 "./asn1/z3950/z3950.cnf" + if (choice >= 0) { + packet_info *pinfo = actx->pinfo; + gint32 tag = PDU_choice[choice].tag; + + col_set_str(pinfo->cinfo, COL_INFO, + val_to_str_const(tag, z3950_PDU_vals, "Unknown Z39.50 PDU")); + } + + + return offset; +} + + + +static int +dissect_z3950_DBName(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset, + hf_index, BER_CLASS_CON, 2, TRUE, dissect_z3950_VisibleString); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_DBName_sequence_of[1] = { + { &hf_z3950_dblist_item , BER_CLASS_CON, 2, BER_FLAGS_NOOWNTAG, dissect_z3950_DBName }, +}; + +static int +dissect_z3950_SEQUENCE_OF_DBName(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_DBName_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_DBName); + + return offset; +} + + +static const ber_sequence_t OCLC_UserInformation_sequence[] = { + { &hf_z3950_motd , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_VisibleString }, + { &hf_z3950_dblist , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_SEQUENCE_OF_DBName }, + { &hf_z3950_failReason , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_oCLC_UserInformation_text, BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_VisibleString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_OCLC_UserInformation(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + OCLC_UserInformation_sequence, hf_index, ett_z3950_OCLC_UserInformation); + + return offset; +} + + + +static int +dissect_z3950_SutrsRecord(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_z3950_InternationalString(implicit_tag, tvb, offset, actx, tree, hf_index); + + return offset; +} + + +static const ber_sequence_t Volume_sequence[] = { + { &hf_z3950_enumeration , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_chronology , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_enumAndChron , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Volume(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + Volume_sequence, hf_index, ett_z3950_Volume); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_Volume_sequence_of[1] = { + { &hf_z3950_volumes_item , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_Volume }, +}; + +static int +dissect_z3950_SEQUENCE_OF_Volume(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_Volume_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_Volume); + + return offset; +} + + +static const ber_sequence_t CircRecord_sequence[] = { + { &hf_z3950_availableNow , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_availablityDate, BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_availableThru , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_circRecord_restrictions, BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_itemId , BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_renewable , BER_CLASS_CON, 6, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_onHold , BER_CLASS_CON, 7, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_enumAndChron , BER_CLASS_CON, 8, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_midspine , BER_CLASS_CON, 9, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_temporaryLocation, BER_CLASS_CON, 10, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_CircRecord(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + CircRecord_sequence, hf_index, ett_z3950_CircRecord); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_CircRecord_sequence_of[1] = { + { &hf_z3950_circulationData_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_CircRecord }, +}; + +static int +dissect_z3950_SEQUENCE_OF_CircRecord(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_CircRecord_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_CircRecord); + + return offset; +} + + +static const ber_sequence_t HoldingsAndCircData_sequence[] = { + { &hf_z3950_typeOfRecord , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_encodingLevel , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_format , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_receiptAcqStatus, BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_generalRetention, BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_completeness , BER_CLASS_CON, 6, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_dateOfReport , BER_CLASS_CON, 7, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_nucCode , BER_CLASS_CON, 8, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_localLocation , BER_CLASS_CON, 9, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_shelvingLocation, BER_CLASS_CON, 10, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_callNumber , BER_CLASS_CON, 11, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_shelvingData , BER_CLASS_CON, 12, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_copyNumber , BER_CLASS_CON, 13, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_publicNote , BER_CLASS_CON, 14, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_reproductionNote, BER_CLASS_CON, 15, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_termsUseRepro , BER_CLASS_CON, 16, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_enumAndChron , BER_CLASS_CON, 17, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_volumes , BER_CLASS_CON, 18, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_Volume }, + { &hf_z3950_circulationData, BER_CLASS_CON, 19, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_CircRecord }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_HoldingsAndCircData(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + HoldingsAndCircData_sequence, hf_index, ett_z3950_HoldingsAndCircData); + + return offset; +} + + +static const value_string z3950_HoldingsRecord_vals[] = { + { 1, "marcHoldingsRecord" }, + { 2, "holdingsAndCirc" }, + { 0, NULL } +}; + +static const ber_choice_t HoldingsRecord_choice[] = { + { 1, &hf_z3950_marcHoldingsRecord, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_EXTERNAL }, + { 2, &hf_z3950_holdingsAndCirc, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_HoldingsAndCircData }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_HoldingsRecord(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + HoldingsRecord_choice, hf_index, ett_z3950_HoldingsRecord, + NULL); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_HoldingsRecord_sequence_of[1] = { + { &hf_z3950_holdingsData_item, BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_HoldingsRecord }, +}; + +static int +dissect_z3950_SEQUENCE_OF_HoldingsRecord(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_HoldingsRecord_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_HoldingsRecord); + + return offset; +} + + +static const ber_sequence_t OPACRecord_sequence[] = { + { &hf_z3950_bibliographicRecord, BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_EXTERNAL }, + { &hf_z3950_holdingsData , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_HoldingsRecord }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_OPACRecord(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + OPACRecord_sequence, hf_index, ett_z3950_OPACRecord); + + return offset; +} + + +static const value_string z3950_T_tooManyWhat_vals[] = { + { 1, "argumentWords" }, + { 2, "truncatedWords" }, + { 3, "booleanOperators" }, + { 4, "incompleteSubfields" }, + { 5, "characters" }, + { 6, "recordsRetrieved" }, + { 7, "dataBasesSpecified" }, + { 8, "resultSetsCreated" }, + { 9, "indexTermsProcessed" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_tooManyWhat(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const ber_sequence_t T_tooMany_sequence[] = { + { &hf_z3950_tooManyWhat , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_T_tooManyWhat }, + { &hf_z3950_max , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_tooMany(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_tooMany_sequence, hf_index, ett_z3950_T_tooMany); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_Specification_sequence_of[1] = { + { &hf_z3950_goodOnes_item , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_Specification }, +}; + +static int +dissect_z3950_SEQUENCE_OF_Specification(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_Specification_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_Specification); + + return offset; +} + + +static const ber_sequence_t T_badSpec_sequence[] = { + { &hf_z3950_spec , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_Specification }, + { &hf_z3950_db , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_DatabaseName }, + { &hf_z3950_goodOnes , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_Specification }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_badSpec(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_badSpec_sequence, hf_index, ett_z3950_T_badSpec); + + return offset; +} + + +static const value_string z3950_T_reasonCode_vals[] = { + { 0, "doesNotExist" }, + { 1, "existsButUnavail" }, + { 2, "locked" }, + { 3, "accessDenied" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_reasonCode(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const ber_sequence_t T_why_sequence[] = { + { &hf_z3950_reasonCode , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_reasonCode }, + { &hf_z3950_message , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_why(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_why_sequence, hf_index, ett_z3950_T_why); + + return offset; +} + + +static const ber_sequence_t T_dbUnavail_sequence[] = { + { &hf_z3950_db , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_DatabaseName }, + { &hf_z3950_why , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_T_why }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_dbUnavail(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_dbUnavail_sequence, hf_index, ett_z3950_T_dbUnavail); + + return offset; +} + + +static const value_string z3950_T_unSupOp_vals[] = { + { 0, "and" }, + { 1, "or" }, + { 2, "and-not" }, + { 3, "prox" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_unSupOp(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const ber_sequence_t T_attribute_sequence[] = { + { &hf_z3950_id , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { &hf_z3950_type , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_value , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_term , BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_NOTCHKTAG, dissect_z3950_Term }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_attribute(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_attribute_sequence, hf_index, ett_z3950_T_attribute); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_AttributeList_sequence_of[1] = { + { &hf_z3950_recommendedAlternatives_item, BER_CLASS_CON, 44, BER_FLAGS_NOOWNTAG, dissect_z3950_AttributeList }, +}; + +static int +dissect_z3950_SEQUENCE_OF_AttributeList(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_AttributeList_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_AttributeList); + + return offset; +} + + +static const ber_sequence_t T_attCombo_sequence[] = { + { &hf_z3950_unsupportedCombination, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_AttributeList }, + { &hf_z3950_recommendedAlternatives, BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_AttributeList }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_attCombo(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_attCombo_sequence, hf_index, ett_z3950_T_attCombo); + + return offset; +} + + +static const value_string z3950_T_problem_vals[] = { + { 1, "codedValue" }, + { 2, "unparsable" }, + { 3, "tooShort" }, + { 4, "type" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_problem(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const ber_sequence_t T_diagFormat_term_sequence[] = { + { &hf_z3950_problem , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_problem }, + { &hf_z3950_term , BER_CLASS_CON, 2, BER_FLAGS_NOTCHKTAG, dissect_z3950_Term }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_diagFormat_term(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_diagFormat_term_sequence, hf_index, ett_z3950_T_diagFormat_term); + + return offset; +} + + +static const value_string z3950_T_diagFormat_proximity_vals[] = { + { 1, "resultSets" }, + { 2, "badSet" }, + { 3, "relation" }, + { 4, "unit" }, + { 5, "distance" }, + { 6, "attributes" }, + { 7, "ordered" }, + { 8, "exclusion" }, + { 0, NULL } +}; + +static const ber_choice_t T_diagFormat_proximity_choice[] = { + { 1, &hf_z3950_resultSets , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 2, &hf_z3950_badSet , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { 3, &hf_z3950_relation , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { 4, &hf_z3950_diagFormat_proximity_unit, BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { 5, &hf_z3950_distance , BER_CLASS_CON, 5, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { 6, &hf_z3950_attributes , BER_CLASS_CON, 6, 0, dissect_z3950_AttributeList }, + { 7, &hf_z3950_diagFormat_proximity_ordered, BER_CLASS_CON, 7, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 8, &hf_z3950_diagFormat_proximity_exclusion, BER_CLASS_CON, 8, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_diagFormat_proximity(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_diagFormat_proximity_choice, hf_index, ett_z3950_T_diagFormat_proximity, + NULL); + + return offset; +} + + +static const value_string z3950_T_posInResponse_vals[] = { + { 1, "mustBeOne" }, + { 2, "mustBePositive" }, + { 3, "mustBeNonNegative" }, + { 4, "other" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_posInResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const value_string z3950_T_scan_vals[] = { + { 0, "nonZeroStepSize" }, + { 1, "specifiedStepSize" }, + { 3, "termList1" }, + { 4, "termList2" }, + { 5, "posInResponse" }, + { 6, "resources" }, + { 7, "endOfList" }, + { 0, NULL } +}; + +static const ber_choice_t T_scan_choice[] = { + { 0, &hf_z3950_nonZeroStepSize, BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 1, &hf_z3950_specifiedStepSize, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 3, &hf_z3950_termList1 , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 4, &hf_z3950_termList2 , BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_AttributeList }, + { 5, &hf_z3950_posInResponse , BER_CLASS_CON, 5, BER_FLAGS_IMPLTAG, dissect_z3950_T_posInResponse }, + { 6, &hf_z3950_resources , BER_CLASS_CON, 6, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 7, &hf_z3950_endOfList , BER_CLASS_CON, 7, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_scan(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_scan_choice, hf_index, ett_z3950_T_scan, + NULL); + + return offset; +} + + +static const value_string z3950_T_key_vals[] = { + { 1, "tooMany" }, + { 2, "duplicate" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_key(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const value_string z3950_T_illegal_vals[] = { + { 1, "relation" }, + { 2, "case" }, + { 3, "action" }, + { 4, "sort" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_illegal(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const value_string z3950_T_sort_vals[] = { + { 0, "sequence" }, + { 1, "noRsName" }, + { 2, "tooMany" }, + { 3, "incompatible" }, + { 4, "generic" }, + { 5, "dbSpecific" }, + { 6, "sortElement" }, + { 7, "key" }, + { 8, "action" }, + { 9, "illegal" }, + { 10, "inputTooLarge" }, + { 11, "aggregateTooLarge" }, + { 0, NULL } +}; + +static const ber_choice_t T_sort_choice[] = { + { 0, &hf_z3950_sequence , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 1, &hf_z3950_noRsName , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 2, &hf_z3950_diagFormat_sort_tooMany, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { 3, &hf_z3950_incompatible , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 4, &hf_z3950_generic , BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 5, &hf_z3950_diagFormat_sort_dbSpecific, BER_CLASS_CON, 5, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 6, &hf_z3950_sortElement , BER_CLASS_CON, 6, 0, dissect_z3950_SortElement }, + { 7, &hf_z3950_key , BER_CLASS_CON, 7, BER_FLAGS_IMPLTAG, dissect_z3950_T_key }, + { 8, &hf_z3950_action , BER_CLASS_CON, 8, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 9, &hf_z3950_illegal , BER_CLASS_CON, 9, BER_FLAGS_IMPLTAG, dissect_z3950_T_illegal }, + { 10, &hf_z3950_inputTooLarge , BER_CLASS_CON, 10, BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_InternationalString }, + { 11, &hf_z3950_aggregateTooLarge, BER_CLASS_CON, 11, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_sort(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_sort_choice, hf_index, ett_z3950_T_sort, + NULL); + + return offset; +} + + +static const value_string z3950_T_segmentation_vals[] = { + { 0, "segmentCount" }, + { 1, "segmentSize" }, + { 0, NULL } +}; + +static const ber_choice_t T_segmentation_choice[] = { + { 0, &hf_z3950_segmentCount , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 1, &hf_z3950_segmentSize , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_segmentation(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_segmentation_choice, hf_index, ett_z3950_T_segmentation, + NULL); + + return offset; +} + + +static const value_string z3950_T_req_vals[] = { + { 1, "nameInUse" }, + { 2, "noSuchName" }, + { 3, "quota" }, + { 4, "type" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_req(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const value_string z3950_T_permission_vals[] = { + { 1, "id" }, + { 2, "modifyDelete" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_permission(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const value_string z3950_T_immediate_vals[] = { + { 1, "failed" }, + { 2, "service" }, + { 3, "parameters" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_immediate(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const value_string z3950_T_extServices_vals[] = { + { 1, "req" }, + { 2, "permission" }, + { 3, "immediate" }, + { 0, NULL } +}; + +static const ber_choice_t T_extServices_choice[] = { + { 1, &hf_z3950_req , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_T_req }, + { 2, &hf_z3950_permission , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_T_permission }, + { 3, &hf_z3950_immediate , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_T_immediate }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_extServices(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_extServices_choice, hf_index, ett_z3950_T_extServices, + NULL); + + return offset; +} + + +static const ber_sequence_t T_diagFormat_accessCtrl_oid_sequence_of[1] = { + { &hf_z3950_diagFormat_accessCtrl_oid_item, BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_z3950_OBJECT_IDENTIFIER }, +}; + +static int +dissect_z3950_T_diagFormat_accessCtrl_oid(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_diagFormat_accessCtrl_oid_sequence_of, hf_index, ett_z3950_T_diagFormat_accessCtrl_oid); + + return offset; +} + + +static const ber_sequence_t T_alternative_sequence_of[1] = { + { &hf_z3950_alternative_item, BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_z3950_OBJECT_IDENTIFIER }, +}; + +static int +dissect_z3950_T_alternative(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_alternative_sequence_of, hf_index, ett_z3950_T_alternative); + + return offset; +} + + +static const value_string z3950_T_accessCtrl_vals[] = { + { 1, "noUser" }, + { 2, "refused" }, + { 3, "simple" }, + { 4, "oid" }, + { 5, "alternative" }, + { 6, "pwdInv" }, + { 7, "pwdExp" }, + { 0, NULL } +}; + +static const ber_choice_t T_accessCtrl_choice[] = { + { 1, &hf_z3950_noUser , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 2, &hf_z3950_refused , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 3, &hf_z3950_diagFormat_accessCtrl_simple, BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 4, &hf_z3950_diagFormat_accessCtrl_oid, BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_z3950_T_diagFormat_accessCtrl_oid }, + { 5, &hf_z3950_alternative , BER_CLASS_CON, 5, BER_FLAGS_IMPLTAG, dissect_z3950_T_alternative }, + { 6, &hf_z3950_pwdInv , BER_CLASS_CON, 6, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 7, &hf_z3950_pwdExp , BER_CLASS_CON, 7, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_accessCtrl(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_accessCtrl_choice, hf_index, ett_z3950_T_accessCtrl, + NULL); + + return offset; +} + + +static const ber_sequence_t T_suggestedAlternatives_sequence_of[1] = { + { &hf_z3950_suggestedAlternatives_item, BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_z3950_OBJECT_IDENTIFIER }, +}; + +static int +dissect_z3950_T_suggestedAlternatives(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_suggestedAlternatives_sequence_of, hf_index, ett_z3950_T_suggestedAlternatives); + + return offset; +} + + +static const ber_sequence_t T_diagFormat_recordSyntax_sequence[] = { + { &hf_z3950_unsupportedSyntax, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { &hf_z3950_suggestedAlternatives, BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_suggestedAlternatives }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_diagFormat_recordSyntax(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_diagFormat_recordSyntax_sequence, hf_index, ett_z3950_T_diagFormat_recordSyntax); + + return offset; +} + + +static const value_string z3950_DiagFormat_vals[] = { + { 1000, "tooMany" }, + { 1001, "badSpec" }, + { 1002, "dbUnavail" }, + { 1003, "unSupOp" }, + { 1004, "attribute" }, + { 1005, "attCombo" }, + { 1006, "term" }, + { 1007, "proximity" }, + { 1008, "scan" }, + { 1009, "sort" }, + { 1010, "segmentation" }, + { 1011, "extServices" }, + { 1012, "accessCtrl" }, + { 1013, "recordSyntax" }, + { 0, NULL } +}; + +static const ber_choice_t DiagFormat_choice[] = { + { 1000, &hf_z3950_tooMany , BER_CLASS_CON, 1000, BER_FLAGS_IMPLTAG, dissect_z3950_T_tooMany }, + { 1001, &hf_z3950_badSpec , BER_CLASS_CON, 1001, BER_FLAGS_IMPLTAG, dissect_z3950_T_badSpec }, + { 1002, &hf_z3950_dbUnavail , BER_CLASS_CON, 1002, BER_FLAGS_IMPLTAG, dissect_z3950_T_dbUnavail }, + { 1003, &hf_z3950_unSupOp , BER_CLASS_CON, 1003, BER_FLAGS_IMPLTAG, dissect_z3950_T_unSupOp }, + { 1004, &hf_z3950_attribute , BER_CLASS_CON, 1004, BER_FLAGS_IMPLTAG, dissect_z3950_T_attribute }, + { 1005, &hf_z3950_attCombo , BER_CLASS_CON, 1005, BER_FLAGS_IMPLTAG, dissect_z3950_T_attCombo }, + { 1006, &hf_z3950_diagFormat_term, BER_CLASS_CON, 1006, BER_FLAGS_IMPLTAG, dissect_z3950_T_diagFormat_term }, + { 1007, &hf_z3950_diagFormat_proximity, BER_CLASS_CON, 1007, 0, dissect_z3950_T_diagFormat_proximity }, + { 1008, &hf_z3950_scan , BER_CLASS_CON, 1008, 0, dissect_z3950_T_scan }, + { 1009, &hf_z3950_sort , BER_CLASS_CON, 1009, 0, dissect_z3950_T_sort }, + { 1010, &hf_z3950_segmentation , BER_CLASS_CON, 1010, 0, dissect_z3950_T_segmentation }, + { 1011, &hf_z3950_extServices , BER_CLASS_CON, 1011, 0, dissect_z3950_T_extServices }, + { 1012, &hf_z3950_accessCtrl , BER_CLASS_CON, 1012, 0, dissect_z3950_T_accessCtrl }, + { 1013, &hf_z3950_diagFormat_recordSyntax, BER_CLASS_CON, 1013, BER_FLAGS_IMPLTAG, dissect_z3950_T_diagFormat_recordSyntax }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_DiagFormat(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + DiagFormat_choice, hf_index, ett_z3950_DiagFormat, + NULL); + + return offset; +} + + +static const value_string z3950_T_diagnosticFormat_item_diagnostic_vals[] = { + { 1, "defaultDiagRec" }, + { 2, "explicitDiagnostic" }, + { 0, NULL } +}; + +static const ber_choice_t T_diagnosticFormat_item_diagnostic_choice[] = { + { 1, &hf_z3950_defaultDiagRec, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_DefaultDiagFormat }, + { 2, &hf_z3950_explicitDiagnostic, BER_CLASS_CON, 2, 0, dissect_z3950_DiagFormat }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_diagnosticFormat_item_diagnostic(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_diagnosticFormat_item_diagnostic_choice, hf_index, ett_z3950_T_diagnosticFormat_item_diagnostic, + NULL); + + return offset; +} + + +static const ber_sequence_t DiagnosticFormat_item_sequence[] = { + { &hf_z3950_diagnosticFormat_item_diagnostic, BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL, dissect_z3950_T_diagnosticFormat_item_diagnostic }, + { &hf_z3950_message , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_DiagnosticFormat_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + DiagnosticFormat_item_sequence, hf_index, ett_z3950_DiagnosticFormat_item); + + return offset; +} + + +static const ber_sequence_t DiagnosticFormat_sequence_of[1] = { + { &hf_z3950_DiagnosticFormat_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_DiagnosticFormat_item }, +}; + +static int +dissect_z3950_DiagnosticFormat(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + DiagnosticFormat_sequence_of, hf_index, ett_z3950_DiagnosticFormat); + + return offset; +} + + + +static int +dissect_z3950_LanguageCode(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_z3950_InternationalString(implicit_tag, tvb, offset, actx, tree, hf_index); + + return offset; +} + + +static const ber_sequence_t CommonInfo_sequence[] = { + { &hf_z3950_dateAdded , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_GeneralizedTime }, + { &hf_z3950_dateChanged , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_GeneralizedTime }, + { &hf_z3950_expiry , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_GeneralizedTime }, + { &hf_z3950_humanString_Language, BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_LanguageCode }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_CommonInfo(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + CommonInfo_sequence, hf_index, ett_z3950_CommonInfo); + + return offset; +} + + +static const ber_sequence_t HumanString_item_sequence[] = { + { &hf_z3950_language , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_LanguageCode }, + { &hf_z3950_text , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_HumanString_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + HumanString_item_sequence, hf_index, ett_z3950_HumanString_item); + + return offset; +} + + +static const ber_sequence_t HumanString_sequence_of[1] = { + { &hf_z3950_HumanString_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_HumanString_item }, +}; + +static int +dissect_z3950_HumanString(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + HumanString_sequence_of, hf_index, ett_z3950_HumanString); + + return offset; +} + + +static const value_string z3950_T_bodyType_vals[] = { + { 1, "ianaType" }, + { 2, "z3950type" }, + { 3, "otherType" }, + { 0, NULL } +}; + +static const ber_choice_t T_bodyType_choice[] = { + { 1, &hf_z3950_ianaType , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { 2, &hf_z3950_z3950type , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { 3, &hf_z3950_otherType , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_bodyType(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_bodyType_choice, hf_index, ett_z3950_T_bodyType, + NULL); + + return offset; +} + + +static const ber_sequence_t IconObject_item_sequence[] = { + { &hf_z3950_bodyType , BER_CLASS_CON, 1, 0, dissect_z3950_T_bodyType }, + { &hf_z3950_content , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_OCTET_STRING }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_IconObject_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + IconObject_item_sequence, hf_index, ett_z3950_IconObject_item); + + return offset; +} + + +static const ber_sequence_t IconObject_sequence_of[1] = { + { &hf_z3950_IconObject_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_IconObject_item }, +}; + +static int +dissect_z3950_IconObject(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + IconObject_sequence_of, hf_index, ett_z3950_IconObject); + + return offset; +} + + +static const ber_sequence_t ContactInfo_sequence[] = { + { &hf_z3950_name , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_description , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_address , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_email , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_phone , BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ContactInfo(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + ContactInfo_sequence, hf_index, ett_z3950_ContactInfo); + + return offset; +} + + +static const ber_sequence_t DatabaseList_sequence_of[1] = { + { &hf_z3950_DatabaseList_item, BER_CLASS_CON, 105, BER_FLAGS_NOOWNTAG, dissect_z3950_DatabaseName }, +}; + +static int +dissect_z3950_DatabaseList(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + DatabaseList_sequence_of, hf_index, ett_z3950_DatabaseList); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_DatabaseList_sequence_of[1] = { + { &hf_z3950_dbCombinations_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_DatabaseList }, +}; + +static int +dissect_z3950_SEQUENCE_OF_DatabaseList(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_DatabaseList_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_DatabaseList); + + return offset; +} + + +static const ber_sequence_t T_internetAddress_sequence[] = { + { &hf_z3950_hostAddress , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_port , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_internetAddress(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_internetAddress_sequence, hf_index, ett_z3950_T_internetAddress); + + return offset; +} + + +static const ber_sequence_t T_osiPresentationAddress_sequence[] = { + { &hf_z3950_pSel , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_sSel , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_tSel , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_nSap , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_osiPresentationAddress(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_osiPresentationAddress_sequence, hf_index, ett_z3950_T_osiPresentationAddress); + + return offset; +} + + +static const ber_sequence_t T_networkAddress_other_sequence[] = { + { &hf_z3950_networkAddress_other_type, BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_networkAddress_other_address, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_networkAddress_other(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_networkAddress_other_sequence, hf_index, ett_z3950_T_networkAddress_other); + + return offset; +} + + +static const value_string z3950_NetworkAddress_vals[] = { + { 0, "internetAddress" }, + { 1, "osiPresentationAddress" }, + { 2, "other" }, + { 0, NULL } +}; + +static const ber_choice_t NetworkAddress_choice[] = { + { 0, &hf_z3950_internetAddress, BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_T_internetAddress }, + { 1, &hf_z3950_osiPresentationAddress, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_T_osiPresentationAddress }, + { 2, &hf_z3950_networkAddress_other, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_T_networkAddress_other }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_NetworkAddress(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + NetworkAddress_choice, hf_index, ett_z3950_NetworkAddress, + NULL); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_NetworkAddress_sequence_of[1] = { + { &hf_z3950_addresses_item, BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_NetworkAddress }, +}; + +static int +dissect_z3950_SEQUENCE_OF_NetworkAddress(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_NetworkAddress_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_NetworkAddress); + + return offset; +} + + +static const ber_sequence_t T_privateCapabilities_operators_item_sequence[] = { + { &hf_z3950_operator , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_description , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_privateCapabilities_operators_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_privateCapabilities_operators_item_sequence, hf_index, ett_z3950_T_privateCapabilities_operators_item); + + return offset; +} + + +static const ber_sequence_t T_privateCapabilities_operators_sequence_of[1] = { + { &hf_z3950_privateCapabilities_operators_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_T_privateCapabilities_operators_item }, +}; + +static int +dissect_z3950_T_privateCapabilities_operators(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_privateCapabilities_operators_sequence_of, hf_index, ett_z3950_T_privateCapabilities_operators); + + return offset; +} + + +static const ber_sequence_t SearchKey_sequence[] = { + { &hf_z3950_searchKey , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_description , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_SearchKey(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + SearchKey_sequence, hf_index, ett_z3950_SearchKey); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_SearchKey_sequence_of[1] = { + { &hf_z3950_searchKeys_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_SearchKey }, +}; + +static int +dissect_z3950_SEQUENCE_OF_SearchKey(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_SearchKey_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_SearchKey); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_HumanString_sequence_of[1] = { + { &hf_z3950_keywords_item , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_HumanString }, +}; + +static int +dissect_z3950_SEQUENCE_OF_HumanString(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_HumanString_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_HumanString); + + return offset; +} + + +static const ber_sequence_t PrivateCapabilities_sequence[] = { + { &hf_z3950_privateCapabilities_operators, BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_privateCapabilities_operators }, + { &hf_z3950_searchKeys , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_SearchKey }, + { &hf_z3950_privateCapabilities_description, BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_HumanString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_PrivateCapabilities(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + PrivateCapabilities_sequence, hf_index, ett_z3950_PrivateCapabilities); + + return offset; +} + + +static const ber_sequence_t T_operators_sequence_of[1] = { + { &hf_z3950_operators_item, BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_z3950_INTEGER }, +}; + +static int +dissect_z3950_T_operators(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_operators_sequence_of, hf_index, ett_z3950_T_operators); + + return offset; +} + + +static const ber_sequence_t T_proximitySupport_unitsSupported_item_private_sequence[] = { + { &hf_z3950_proximitySupport_unitsSupported_item_private_unit, BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_description , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL, dissect_z3950_HumanString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_proximitySupport_unitsSupported_item_private(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_proximitySupport_unitsSupported_item_private_sequence, hf_index, ett_z3950_T_proximitySupport_unitsSupported_item_private); + + return offset; +} + + +static const value_string z3950_T_unitsSupported_item_vals[] = { + { 1, "known" }, + { 2, "private" }, + { 0, NULL } +}; + +static const ber_choice_t T_unitsSupported_item_choice[] = { + { 1, &hf_z3950_proximitySupport_unitsSupported_item_known, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { 2, &hf_z3950_proximitySupport_unitsSupported_item_private, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_T_proximitySupport_unitsSupported_item_private }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_unitsSupported_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_unitsSupported_item_choice, hf_index, ett_z3950_T_unitsSupported_item, + NULL); + + return offset; +} + + +static const ber_sequence_t T_unitsSupported_sequence_of[1] = { + { &hf_z3950_unitsSupported_item, BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_T_unitsSupported_item }, +}; + +static int +dissect_z3950_T_unitsSupported(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_unitsSupported_sequence_of, hf_index, ett_z3950_T_unitsSupported); + + return offset; +} + + +static const ber_sequence_t ProximitySupport_sequence[] = { + { &hf_z3950_anySupport , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_unitsSupported, BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_unitsSupported }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ProximitySupport(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + ProximitySupport_sequence, hf_index, ett_z3950_ProximitySupport); + + return offset; +} + + +static const ber_sequence_t RpnCapabilities_sequence[] = { + { &hf_z3950_operators , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_operators }, + { &hf_z3950_resultSetAsOperandSupported, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_restrictionOperandSupported, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_proximity , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_ProximitySupport }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_RpnCapabilities(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + RpnCapabilities_sequence, hf_index, ett_z3950_RpnCapabilities); + + return offset; +} + + +static const ber_sequence_t Iso8777Capabilities_sequence[] = { + { &hf_z3950_searchKeys , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_SearchKey }, + { &hf_z3950_restrictions , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Iso8777Capabilities(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + Iso8777Capabilities_sequence, hf_index, ett_z3950_Iso8777Capabilities); + + return offset; +} + + +static const value_string z3950_QueryTypeDetails_vals[] = { + { 0, "private" }, + { 1, "rpn" }, + { 2, "iso8777" }, + { 100, "z39-58" }, + { 101, "erpn" }, + { 102, "rankedList" }, + { 0, NULL } +}; + +static const ber_choice_t QueryTypeDetails_choice[] = { + { 0, &hf_z3950_queryTypeDetails_private, BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_PrivateCapabilities }, + { 1, &hf_z3950_queryTypeDetails_rpn, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_RpnCapabilities }, + { 2, &hf_z3950_iso8777 , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_Iso8777Capabilities }, + { 100, &hf_z3950_z39_58 , BER_CLASS_CON, 100, BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { 101, &hf_z3950_erpn , BER_CLASS_CON, 101, BER_FLAGS_IMPLTAG, dissect_z3950_RpnCapabilities }, + { 102, &hf_z3950_rankedList , BER_CLASS_CON, 102, BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_QueryTypeDetails(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + QueryTypeDetails_choice, hf_index, ett_z3950_QueryTypeDetails, + NULL); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_QueryTypeDetails_sequence_of[1] = { + { &hf_z3950_queryTypesSupported_item, BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_QueryTypeDetails }, +}; + +static int +dissect_z3950_SEQUENCE_OF_QueryTypeDetails(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_QueryTypeDetails_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_QueryTypeDetails); + + return offset; +} + + +static const ber_sequence_t T_diagnosticsSets_sequence_of[1] = { + { &hf_z3950_diagnosticsSets_item, BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_z3950_OBJECT_IDENTIFIER }, +}; + +static int +dissect_z3950_T_diagnosticsSets(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_diagnosticsSets_sequence_of, hf_index, ett_z3950_T_diagnosticsSets); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_AttributeSetId_sequence_of[1] = { + { &hf_z3950_attributeSetIds_item, BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_z3950_AttributeSetId }, +}; + +static int +dissect_z3950_SEQUENCE_OF_AttributeSetId(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_AttributeSetId_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_AttributeSetId); + + return offset; +} + + +static const ber_sequence_t T_schemas_sequence_of[1] = { + { &hf_z3950_schemas_item , BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_z3950_OBJECT_IDENTIFIER }, +}; + +static int +dissect_z3950_T_schemas(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_schemas_sequence_of, hf_index, ett_z3950_T_schemas); + + return offset; +} + + +static const ber_sequence_t T_recordSyntaxes_sequence_of[1] = { + { &hf_z3950_recordSyntaxes_item, BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_z3950_OBJECT_IDENTIFIER }, +}; + +static int +dissect_z3950_T_recordSyntaxes(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_recordSyntaxes_sequence_of, hf_index, ett_z3950_T_recordSyntaxes); + + return offset; +} + + +static const ber_sequence_t T_resourceChallenges_sequence_of[1] = { + { &hf_z3950_resourceChallenges_item, BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_z3950_OBJECT_IDENTIFIER }, +}; + +static int +dissect_z3950_T_resourceChallenges(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_resourceChallenges_sequence_of, hf_index, ett_z3950_T_resourceChallenges); + + return offset; +} + + +static const value_string z3950_T_accessType_vals[] = { + { 0, "any" }, + { 1, "search" }, + { 2, "present" }, + { 3, "specific-elements" }, + { 4, "extended-services" }, + { 5, "by-database" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_accessType(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const ber_sequence_t T_accessChallenges_sequence_of[1] = { + { &hf_z3950_accessChallenges_item, BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_z3950_OBJECT_IDENTIFIER }, +}; + +static int +dissect_z3950_T_accessChallenges(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_accessChallenges_sequence_of, hf_index, ett_z3950_T_accessChallenges); + + return offset; +} + + +static const ber_sequence_t AccessRestrictions_item_sequence[] = { + { &hf_z3950_accessType , BER_CLASS_CON, 0, 0, dissect_z3950_T_accessType }, + { &hf_z3950_accessText , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_accessChallenges, BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_accessChallenges }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_AccessRestrictions_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + AccessRestrictions_item_sequence, hf_index, ett_z3950_AccessRestrictions_item); + + return offset; +} + + +static const ber_sequence_t AccessRestrictions_sequence_of[1] = { + { &hf_z3950_AccessRestrictions_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_AccessRestrictions_item }, +}; + +static int +dissect_z3950_AccessRestrictions(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + AccessRestrictions_sequence_of, hf_index, ett_z3950_AccessRestrictions); + + return offset; +} + + +static const ber_sequence_t Charge_sequence[] = { + { &hf_z3950_cost , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_IntUnit }, + { &hf_z3950_perWhat , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_Unit }, + { &hf_z3950_charge_text , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Charge(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + Charge_sequence, hf_index, ett_z3950_Charge); + + return offset; +} + + +static const ber_sequence_t T_otherCharges_item_sequence[] = { + { &hf_z3950_forWhat , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_charge , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_Charge }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_otherCharges_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_otherCharges_item_sequence, hf_index, ett_z3950_T_otherCharges_item); + + return offset; +} + + +static const ber_sequence_t T_otherCharges_sequence_of[1] = { + { &hf_z3950_otherCharges_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_T_otherCharges_item }, +}; + +static int +dissect_z3950_T_otherCharges(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_otherCharges_sequence_of, hf_index, ett_z3950_T_otherCharges); + + return offset; +} + + +static const ber_sequence_t Costs_sequence[] = { + { &hf_z3950_connectCharge , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_Charge }, + { &hf_z3950_connectTime , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_Charge }, + { &hf_z3950_displayCharge , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_Charge }, + { &hf_z3950_searchCharge , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_Charge }, + { &hf_z3950_subscriptCharge, BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_Charge }, + { &hf_z3950_otherCharges , BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_otherCharges }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Costs(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + Costs_sequence, hf_index, ett_z3950_Costs); + + return offset; +} + + +static const ber_sequence_t T_variantSets_sequence_of[1] = { + { &hf_z3950_variantSets_item, BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_z3950_OBJECT_IDENTIFIER }, +}; + +static int +dissect_z3950_T_variantSets(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_variantSets_sequence_of, hf_index, ett_z3950_T_variantSets); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_ElementSetName_sequence_of[1] = { + { &hf_z3950_elementSetNames_item, BER_CLASS_CON, 103, BER_FLAGS_NOOWNTAG, dissect_z3950_ElementSetName }, +}; + +static int +dissect_z3950_SEQUENCE_OF_ElementSetName(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_ElementSetName_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_ElementSetName); + + return offset; +} + + +static const ber_sequence_t AccessInfo_sequence[] = { + { &hf_z3950_queryTypesSupported, BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_QueryTypeDetails }, + { &hf_z3950_diagnosticsSets, BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_diagnosticsSets }, + { &hf_z3950_attributeSetIds, BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_AttributeSetId }, + { &hf_z3950_schemas , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_schemas }, + { &hf_z3950_recordSyntaxes, BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_recordSyntaxes }, + { &hf_z3950_resourceChallenges, BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_resourceChallenges }, + { &hf_z3950_restrictedAccess, BER_CLASS_CON, 6, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_AccessRestrictions }, + { &hf_z3950_costInfo , BER_CLASS_CON, 8, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_Costs }, + { &hf_z3950_variantSets , BER_CLASS_CON, 9, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_variantSets }, + { &hf_z3950_elementSetNames, BER_CLASS_CON, 10, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_ElementSetName }, + { &hf_z3950_unitSystems , BER_CLASS_CON, 11, BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_InternationalString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_AccessInfo(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + AccessInfo_sequence, hf_index, ett_z3950_AccessInfo); + + return offset; +} + + +static const ber_sequence_t TargetInfo_sequence[] = { + { &hf_z3950_commonInfo , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_CommonInfo }, + { &hf_z3950_name , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_recent_news , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_icon , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_IconObject }, + { &hf_z3950_namedResultSets, BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_multipleDBsearch, BER_CLASS_CON, 5, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_maxResultSets , BER_CLASS_CON, 6, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_maxResultSize , BER_CLASS_CON, 7, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_maxTerms , BER_CLASS_CON, 8, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_timeoutInterval, BER_CLASS_CON, 9, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_IntUnit }, + { &hf_z3950_welcomeMessage, BER_CLASS_CON, 10, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_contactInfo , BER_CLASS_CON, 11, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_ContactInfo }, + { &hf_z3950_description , BER_CLASS_CON, 12, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_nicknames , BER_CLASS_CON, 13, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_InternationalString }, + { &hf_z3950_usage_restrictions, BER_CLASS_CON, 14, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_paymentAddr , BER_CLASS_CON, 15, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_hours , BER_CLASS_CON, 16, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_dbCombinations, BER_CLASS_CON, 17, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_DatabaseList }, + { &hf_z3950_addresses , BER_CLASS_CON, 18, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_NetworkAddress }, + { &hf_z3950_languages , BER_CLASS_CON, 101, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_InternationalString }, + { &hf_z3950_commonAccessInfo, BER_CLASS_CON, 19, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_AccessInfo }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_TargetInfo(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + TargetInfo_sequence, hf_index, ett_z3950_TargetInfo); + + return offset; +} + + +static const value_string z3950_T_recordCount_vals[] = { + { 0, "actualNumber" }, + { 1, "approxNumber" }, + { 0, NULL } +}; + +static const ber_choice_t T_recordCount_choice[] = { + { 0, &hf_z3950_actualNumber , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { 1, &hf_z3950_approxNumber , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_recordCount(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_recordCount_choice, hf_index, ett_z3950_T_recordCount, + NULL); + + return offset; +} + + +static const ber_sequence_t DatabaseInfo_sequence[] = { + { &hf_z3950_commonInfo , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_CommonInfo }, + { &hf_z3950_databaseInfo_name, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_DatabaseName }, + { &hf_z3950_explainDatabase, BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { &hf_z3950_databaseInfo_nicknames, BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_DatabaseName }, + { &hf_z3950_icon , BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_IconObject }, + { &hf_z3950_user_fee , BER_CLASS_CON, 5, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_available , BER_CLASS_CON, 6, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_titleString , BER_CLASS_CON, 7, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_keywords , BER_CLASS_CON, 8, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_HumanString }, + { &hf_z3950_description , BER_CLASS_CON, 9, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_associatedDbs , BER_CLASS_CON, 10, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_DatabaseList }, + { &hf_z3950_subDbs , BER_CLASS_CON, 11, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_DatabaseList }, + { &hf_z3950_disclaimers , BER_CLASS_CON, 12, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_news , BER_CLASS_CON, 13, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_recordCount , BER_CLASS_CON, 14, BER_FLAGS_OPTIONAL, dissect_z3950_T_recordCount }, + { &hf_z3950_defaultOrder , BER_CLASS_CON, 15, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_avRecordSize , BER_CLASS_CON, 16, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_maxRecordSize , BER_CLASS_CON, 17, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_hours , BER_CLASS_CON, 18, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_bestTime , BER_CLASS_CON, 19, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_lastUpdate , BER_CLASS_CON, 20, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_GeneralizedTime }, + { &hf_z3950_updateInterval, BER_CLASS_CON, 21, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_IntUnit }, + { &hf_z3950_coverage , BER_CLASS_CON, 22, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_proprietary , BER_CLASS_CON, 23, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_copyrightText , BER_CLASS_CON, 24, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_copyrightNotice, BER_CLASS_CON, 25, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_producerContactInfo, BER_CLASS_CON, 26, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_ContactInfo }, + { &hf_z3950_supplierContactInfo, BER_CLASS_CON, 27, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_ContactInfo }, + { &hf_z3950_submissionContactInfo, BER_CLASS_CON, 28, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_ContactInfo }, + { &hf_z3950_accessInfo , BER_CLASS_CON, 29, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_AccessInfo }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_DatabaseInfo(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + DatabaseInfo_sequence, hf_index, ett_z3950_DatabaseInfo); + + return offset; +} + + +static const ber_sequence_t T_tagTypeMapping_item_sequence[] = { + { &hf_z3950_tagType , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_tagSet , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { &hf_z3950_defaultTagType, BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_tagTypeMapping_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_tagTypeMapping_item_sequence, hf_index, ett_z3950_T_tagTypeMapping_item); + + return offset; +} + + +static const ber_sequence_t T_tagTypeMapping_sequence_of[1] = { + { &hf_z3950_tagTypeMapping_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_T_tagTypeMapping_item }, +}; + +static int +dissect_z3950_T_tagTypeMapping(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_tagTypeMapping_sequence_of, hf_index, ett_z3950_T_tagTypeMapping); + + return offset; +} + + +static const ber_sequence_t Path_item_sequence[] = { + { &hf_z3950_tagType , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_tagValue , BER_CLASS_CON, 2, BER_FLAGS_NOTCHKTAG, dissect_z3950_StringOrNumeric }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Path_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + Path_item_sequence, hf_index, ett_z3950_Path_item); + + return offset; +} + + +static const ber_sequence_t Path_sequence_of[1] = { + { &hf_z3950_Path_item , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_Path_item }, +}; + +static int +dissect_z3950_Path(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + Path_sequence_of, hf_index, ett_z3950_Path); + + return offset; +} + + +static const value_string z3950_PrimitiveDataType_vals[] = { + { 0, "octetString" }, + { 1, "numeric" }, + { 2, "date" }, + { 3, "external" }, + { 4, "string" }, + { 5, "trueOrFalse" }, + { 6, "oid" }, + { 7, "intUnit" }, + { 8, "empty" }, + { 100, "noneOfTheAbove" }, + { 0, NULL } +}; + + +static int +dissect_z3950_PrimitiveDataType(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_ElementInfo_sequence_of[1] = { + { &hf_z3950_recordStructure_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_ElementInfo }, +}; + +static int +dissect_z3950_SEQUENCE_OF_ElementInfo(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_ElementInfo_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_ElementInfo); + + return offset; +} + + +static const value_string z3950_ElementDataType_vals[] = { + { 0, "primitive" }, + { 1, "structured" }, + { 0, NULL } +}; + +static const ber_choice_t ElementDataType_choice[] = { + { 0, &hf_z3950_primitive , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_PrimitiveDataType }, + { 1, &hf_z3950_structured , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_ElementInfo }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ElementDataType(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + ElementDataType_choice, hf_index, ett_z3950_ElementDataType, + NULL); + + return offset; +} + + +static const ber_sequence_t ElementInfo_sequence[] = { + { &hf_z3950_elementName , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_elementTagPath, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_Path }, + { &hf_z3950_elementInfo_dataType, BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_NOTCHKTAG, dissect_z3950_ElementDataType }, + { &hf_z3950_required , BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_repeatable , BER_CLASS_CON, 5, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_description , BER_CLASS_CON, 6, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ElementInfo(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + ElementInfo_sequence, hf_index, ett_z3950_ElementInfo); + + return offset; +} + + +static const ber_sequence_t SchemaInfo_sequence[] = { + { &hf_z3950_commonInfo , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_CommonInfo }, + { &hf_z3950_schema , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { &hf_z3950_name , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_description , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_tagTypeMapping, BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_tagTypeMapping }, + { &hf_z3950_recordStructure, BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_ElementInfo }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_SchemaInfo(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + SchemaInfo_sequence, hf_index, ett_z3950_SchemaInfo); + + return offset; +} + + +static const ber_sequence_t T_tagSetInfo_elements_item_sequence[] = { + { &hf_z3950_elementname , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_nicknames , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_InternationalString }, + { &hf_z3950_elementTag , BER_CLASS_CON, 3, BER_FLAGS_NOTCHKTAG, dissect_z3950_StringOrNumeric }, + { &hf_z3950_description , BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_dataType , BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL, dissect_z3950_PrimitiveDataType }, + { &hf_z3950_otherTagInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_tagSetInfo_elements_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_tagSetInfo_elements_item_sequence, hf_index, ett_z3950_T_tagSetInfo_elements_item); + + return offset; +} + + +static const ber_sequence_t T_tagSetInfo_elements_sequence_of[1] = { + { &hf_z3950_tagSetInfo_elements_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_T_tagSetInfo_elements_item }, +}; + +static int +dissect_z3950_T_tagSetInfo_elements(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_tagSetInfo_elements_sequence_of, hf_index, ett_z3950_T_tagSetInfo_elements); + + return offset; +} + + +static const ber_sequence_t TagSetInfo_sequence[] = { + { &hf_z3950_commonInfo , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_CommonInfo }, + { &hf_z3950_tagSet , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { &hf_z3950_name , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_description , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_tagSetInfo_elements, BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_tagSetInfo_elements }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_TagSetInfo(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + TagSetInfo_sequence, hf_index, ett_z3950_TagSetInfo); + + return offset; +} + + +static const ber_sequence_t T_transferSyntaxes_sequence_of[1] = { + { &hf_z3950_transferSyntaxes_item, BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_z3950_OBJECT_IDENTIFIER }, +}; + +static int +dissect_z3950_T_transferSyntaxes(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_transferSyntaxes_sequence_of, hf_index, ett_z3950_T_transferSyntaxes); + + return offset; +} + + +static const ber_sequence_t RecordSyntaxInfo_sequence[] = { + { &hf_z3950_commonInfo , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_CommonInfo }, + { &hf_z3950_recordSyntax , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { &hf_z3950_name , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_transferSyntaxes, BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_transferSyntaxes }, + { &hf_z3950_description , BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_asn1Module , BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_abstractStructure, BER_CLASS_CON, 6, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_ElementInfo }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_RecordSyntaxInfo(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + RecordSyntaxInfo_sequence, hf_index, ett_z3950_RecordSyntaxInfo); + + return offset; +} + + +static const ber_sequence_t AttributeDescription_sequence[] = { + { &hf_z3950_name , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_description , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_attributeDescription_attributeValue, BER_CLASS_CON, 2, BER_FLAGS_NOTCHKTAG, dissect_z3950_StringOrNumeric }, + { &hf_z3950_equivalentAttributes, BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_StringOrNumeric }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_AttributeDescription(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + AttributeDescription_sequence, hf_index, ett_z3950_AttributeDescription); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_AttributeDescription_sequence_of[1] = { + { &hf_z3950_attributeValues_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_AttributeDescription }, +}; + +static int +dissect_z3950_SEQUENCE_OF_AttributeDescription(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_AttributeDescription_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_AttributeDescription); + + return offset; +} + + +static const ber_sequence_t AttributeType_sequence[] = { + { &hf_z3950_name , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_description , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_attributeType , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_attributeValues, BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_AttributeDescription }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_AttributeType(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + AttributeType_sequence, hf_index, ett_z3950_AttributeType); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_AttributeType_sequence_of[1] = { + { &hf_z3950_attributeSetInfo_attributes_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_AttributeType }, +}; + +static int +dissect_z3950_SEQUENCE_OF_AttributeType(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_AttributeType_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_AttributeType); + + return offset; +} + + +static const ber_sequence_t AttributeSetInfo_sequence[] = { + { &hf_z3950_commonInfo , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_CommonInfo }, + { &hf_z3950_attributeSet , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_AttributeSetId }, + { &hf_z3950_name , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_attributeSetInfo_attributes, BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_AttributeType }, + { &hf_z3950_description , BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_AttributeSetInfo(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + AttributeSetInfo_sequence, hf_index, ett_z3950_AttributeSetInfo); + + return offset; +} + + +static const value_string z3950_T_searchCost_vals[] = { + { 0, "optimized" }, + { 1, "normal" }, + { 2, "expensive" }, + { 3, "filter" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_searchCost(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const ber_sequence_t T_termLists_item_sequence[] = { + { &hf_z3950_name , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_title , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_searchCost , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_searchCost }, + { &hf_z3950_scanable , BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_broader , BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_InternationalString }, + { &hf_z3950_narrower , BER_CLASS_CON, 6, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_InternationalString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_termLists_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_termLists_item_sequence, hf_index, ett_z3950_T_termLists_item); + + return offset; +} + + +static const ber_sequence_t T_termLists_sequence_of[1] = { + { &hf_z3950_termLists_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_T_termLists_item }, +}; + +static int +dissect_z3950_T_termLists(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_termLists_sequence_of, hf_index, ett_z3950_T_termLists); + + return offset; +} + + +static const ber_sequence_t TermListInfo_sequence[] = { + { &hf_z3950_commonInfo , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_CommonInfo }, + { &hf_z3950_databaseName , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_DatabaseName }, + { &hf_z3950_termLists , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_T_termLists }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_TermListInfo(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + TermListInfo_sequence, hf_index, ett_z3950_TermListInfo); + + return offset; +} + + +static const value_string z3950_T_extendedServicesInfo_waitAction_vals[] = { + { 1, "waitSupported" }, + { 2, "waitAlways" }, + { 3, "waitNotSupported" }, + { 4, "depends" }, + { 5, "notSaying" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_extendedServicesInfo_waitAction(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const ber_sequence_t ExtendedServicesInfo_sequence[] = { + { &hf_z3950_commonInfo , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_CommonInfo }, + { &hf_z3950_extendedServicesInfo_type, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { &hf_z3950_name , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_privateType , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_restrictionsApply, BER_CLASS_CON, 5, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_feeApply , BER_CLASS_CON, 6, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_available , BER_CLASS_CON, 7, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_retentionSupported, BER_CLASS_CON, 8, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_extendedServicesInfo_waitAction, BER_CLASS_CON, 9, BER_FLAGS_IMPLTAG, dissect_z3950_T_extendedServicesInfo_waitAction }, + { &hf_z3950_description , BER_CLASS_CON, 10, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_specificExplain, BER_CLASS_CON, 11, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_EXTERNAL }, + { &hf_z3950_esASN , BER_CLASS_CON, 12, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ExtendedServicesInfo(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + ExtendedServicesInfo_sequence, hf_index, ett_z3950_ExtendedServicesInfo); + + return offset; +} + + +static const ber_sequence_t OmittedAttributeInterpretation_sequence[] = { + { &hf_z3950_defaultValue , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_NOTCHKTAG, dissect_z3950_StringOrNumeric }, + { &hf_z3950_defaultDescription, BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_OmittedAttributeInterpretation(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + OmittedAttributeInterpretation_sequence, hf_index, ett_z3950_OmittedAttributeInterpretation); + + return offset; +} + + +static const ber_sequence_t AttributeValue_sequence[] = { + { &hf_z3950_attributeValue_value, BER_CLASS_CON, 0, BER_FLAGS_NOTCHKTAG, dissect_z3950_StringOrNumeric }, + { &hf_z3950_description , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_subAttributes , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_StringOrNumeric }, + { &hf_z3950_superAttributes, BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_StringOrNumeric }, + { &hf_z3950_partialSupport, BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_AttributeValue(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + AttributeValue_sequence, hf_index, ett_z3950_AttributeValue); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_AttributeValue_sequence_of[1] = { + { &hf_z3950_attributeTypeDetails_attributeValues_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_AttributeValue }, +}; + +static int +dissect_z3950_SEQUENCE_OF_AttributeValue(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_AttributeValue_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_AttributeValue); + + return offset; +} + + +static const ber_sequence_t AttributeTypeDetails_sequence[] = { + { &hf_z3950_attributeType , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_defaultIfOmitted, BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_OmittedAttributeInterpretation }, + { &hf_z3950_attributeTypeDetails_attributeValues, BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_AttributeValue }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_AttributeTypeDetails(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + AttributeTypeDetails_sequence, hf_index, ett_z3950_AttributeTypeDetails); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_AttributeTypeDetails_sequence_of[1] = { + { &hf_z3950_attributesByType_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_AttributeTypeDetails }, +}; + +static int +dissect_z3950_SEQUENCE_OF_AttributeTypeDetails(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_AttributeTypeDetails_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_AttributeTypeDetails); + + return offset; +} + + +static const ber_sequence_t AttributeSetDetails_sequence[] = { + { &hf_z3950_attributeSet , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_AttributeSetId }, + { &hf_z3950_attributesByType, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_AttributeTypeDetails }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_AttributeSetDetails(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + AttributeSetDetails_sequence, hf_index, ett_z3950_AttributeSetDetails); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_AttributeSetDetails_sequence_of[1] = { + { &hf_z3950_attributesBySet_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_AttributeSetDetails }, +}; + +static int +dissect_z3950_SEQUENCE_OF_AttributeSetDetails(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_AttributeSetDetails_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_AttributeSetDetails); + + return offset; +} + + +static const value_string z3950_T_attributeOccurrence_attributeValues_vals[] = { + { 3, "any-or-none" }, + { 4, "specific" }, + { 0, NULL } +}; + +static const ber_choice_t T_attributeOccurrence_attributeValues_choice[] = { + { 3, &hf_z3950_any_or_none , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 4, &hf_z3950_specific , BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_StringOrNumeric }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_attributeOccurrence_attributeValues(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_attributeOccurrence_attributeValues_choice, hf_index, ett_z3950_T_attributeOccurrence_attributeValues, + NULL); + + return offset; +} + + +static const ber_sequence_t AttributeOccurrence_sequence[] = { + { &hf_z3950_attributeSet , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_AttributeSetId }, + { &hf_z3950_attributeType , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_mustBeSupplied, BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { &hf_z3950_attributeOccurrence_attributeValues, BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_T_attributeOccurrence_attributeValues }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_AttributeOccurrence(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + AttributeOccurrence_sequence, hf_index, ett_z3950_AttributeOccurrence); + + return offset; +} + + +static const ber_sequence_t AttributeCombination_sequence_of[1] = { + { &hf_z3950_AttributeCombination_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_AttributeOccurrence }, +}; + +static int +dissect_z3950_AttributeCombination(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + AttributeCombination_sequence_of, hf_index, ett_z3950_AttributeCombination); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_AttributeCombination_sequence_of[1] = { + { &hf_z3950_legalCombinations_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_AttributeCombination }, +}; + +static int +dissect_z3950_SEQUENCE_OF_AttributeCombination(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_AttributeCombination_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_AttributeCombination); + + return offset; +} + + +static const ber_sequence_t AttributeCombinations_sequence[] = { + { &hf_z3950_defaultAttributeSet, BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_AttributeSetId }, + { &hf_z3950_legalCombinations, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_AttributeCombination }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_AttributeCombinations(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + AttributeCombinations_sequence, hf_index, ett_z3950_AttributeCombinations); + + return offset; +} + + +static const ber_sequence_t AttributeDetails_sequence[] = { + { &hf_z3950_commonInfo , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_CommonInfo }, + { &hf_z3950_databaseName , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_DatabaseName }, + { &hf_z3950_attributesBySet, BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_AttributeSetDetails }, + { &hf_z3950_attributeCombinations, BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_AttributeCombinations }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_AttributeDetails(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + AttributeDetails_sequence, hf_index, ett_z3950_AttributeDetails); + + return offset; +} + + +static const ber_sequence_t T_scanInfo_sequence[] = { + { &hf_z3950_maxStepSize , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_collatingSequence, BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_increasing , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_scanInfo(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_scanInfo_sequence, hf_index, ett_z3950_T_scanInfo); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_Term_sequence_of[1] = { + { &hf_z3950_sampleTerms_item, BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_Term }, +}; + +static int +dissect_z3950_SEQUENCE_OF_Term(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_Term_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_Term); + + return offset; +} + + +static const ber_sequence_t TermListDetails_sequence[] = { + { &hf_z3950_commonInfo , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_CommonInfo }, + { &hf_z3950_termListName , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_description , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_termListDetails_attributes, BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_AttributeCombinations }, + { &hf_z3950_scanInfo , BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_scanInfo }, + { &hf_z3950_estNumberTerms, BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_sampleTerms , BER_CLASS_CON, 6, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_Term }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_TermListDetails(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + TermListDetails_sequence, hf_index, ett_z3950_TermListDetails); + + return offset; +} + + +static const ber_sequence_t RecordTag_sequence[] = { + { &hf_z3950_qualifier , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_NOTCHKTAG, dissect_z3950_StringOrNumeric }, + { &hf_z3950_tagValue , BER_CLASS_CON, 1, BER_FLAGS_NOTCHKTAG, dissect_z3950_StringOrNumeric }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_RecordTag(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + RecordTag_sequence, hf_index, ett_z3950_RecordTag); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_Path_sequence_of[1] = { + { &hf_z3950_schemaTags_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_Path }, +}; + +static int +dissect_z3950_SEQUENCE_OF_Path(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_Path_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_Path); + + return offset; +} + + +static const ber_sequence_t PerElementDetails_sequence[] = { + { &hf_z3950_name , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_recordTag , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_RecordTag }, + { &hf_z3950_schemaTags , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_Path }, + { &hf_z3950_maxSize , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_minSize , BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_avgSize , BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_fixedSize , BER_CLASS_CON, 6, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_repeatable , BER_CLASS_CON, 8, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_required , BER_CLASS_CON, 9, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_description , BER_CLASS_CON, 12, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_contents , BER_CLASS_CON, 13, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_billingInfo , BER_CLASS_CON, 14, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_restrictions , BER_CLASS_CON, 15, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_alternateNames, BER_CLASS_CON, 16, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_InternationalString }, + { &hf_z3950_genericNames , BER_CLASS_CON, 17, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_InternationalString }, + { &hf_z3950_searchAccess , BER_CLASS_CON, 18, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_AttributeCombinations }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_PerElementDetails(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + PerElementDetails_sequence, hf_index, ett_z3950_PerElementDetails); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_PerElementDetails_sequence_of[1] = { + { &hf_z3950_detailsPerElement_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_PerElementDetails }, +}; + +static int +dissect_z3950_SEQUENCE_OF_PerElementDetails(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_PerElementDetails_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_PerElementDetails); + + return offset; +} + + +static const ber_sequence_t ElementSetDetails_sequence[] = { + { &hf_z3950_commonInfo , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_CommonInfo }, + { &hf_z3950_databaseName , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_DatabaseName }, + { &hf_z3950_elementSetDetails_elementSetName, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_ElementSetName }, + { &hf_z3950_recordSyntax , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { &hf_z3950_schema , BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { &hf_z3950_description , BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_detailsPerElement, BER_CLASS_CON, 6, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_PerElementDetails }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ElementSetDetails(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + ElementSetDetails_sequence, hf_index, ett_z3950_ElementSetDetails); + + return offset; +} + + +static const ber_sequence_t RetrievalRecordDetails_sequence[] = { + { &hf_z3950_commonInfo , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_CommonInfo }, + { &hf_z3950_databaseName , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_DatabaseName }, + { &hf_z3950_schema , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { &hf_z3950_recordSyntax , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { &hf_z3950_description , BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_detailsPerElement, BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_PerElementDetails }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_RetrievalRecordDetails(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + RetrievalRecordDetails_sequence, hf_index, ett_z3950_RetrievalRecordDetails); + + return offset; +} + + +static const value_string z3950_T_sortType_vals[] = { + { 0, "character" }, + { 1, "numeric" }, + { 2, "structured" }, + { 0, NULL } +}; + +static const ber_choice_t T_sortType_choice[] = { + { 0, &hf_z3950_character , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 1, &hf_z3950_sortKeyDetails_sortType_numeric, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 2, &hf_z3950_sortKeyDetails_sortType_structured, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_sortType(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_sortType_choice, hf_index, ett_z3950_T_sortType, + NULL); + + return offset; +} + + +static const value_string z3950_T_sortKeyDetails_caseSensitivity_vals[] = { + { 0, "always" }, + { 1, "never" }, + { 2, "default-yes" }, + { 3, "default-no" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_sortKeyDetails_caseSensitivity(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const ber_sequence_t SortKeyDetails_sequence[] = { + { &hf_z3950_description , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_elementSpecifications, BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_Specification }, + { &hf_z3950_attributeSpecifications, BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_AttributeCombinations }, + { &hf_z3950_sortType , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL, dissect_z3950_T_sortType }, + { &hf_z3950_sortKeyDetails_caseSensitivity, BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_sortKeyDetails_caseSensitivity }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_SortKeyDetails(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + SortKeyDetails_sequence, hf_index, ett_z3950_SortKeyDetails); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_SortKeyDetails_sequence_of[1] = { + { &hf_z3950_sortKeys_item , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_SortKeyDetails }, +}; + +static int +dissect_z3950_SEQUENCE_OF_SortKeyDetails(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_SortKeyDetails_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_SortKeyDetails); + + return offset; +} + + +static const ber_sequence_t SortDetails_sequence[] = { + { &hf_z3950_commonInfo , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_CommonInfo }, + { &hf_z3950_databaseName , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_DatabaseName }, + { &hf_z3950_sortKeys , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_SortKeyDetails }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_SortDetails(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + SortDetails_sequence, hf_index, ett_z3950_SortDetails); + + return offset; +} + + +static const value_string z3950_T_processingContext_vals[] = { + { 0, "access" }, + { 1, "search" }, + { 2, "retrieval" }, + { 3, "record-presentation" }, + { 4, "record-handling" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_processingContext(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const ber_sequence_t ProcessingInformation_sequence[] = { + { &hf_z3950_commonInfo , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_CommonInfo }, + { &hf_z3950_databaseName , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_DatabaseName }, + { &hf_z3950_processingContext, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_T_processingContext }, + { &hf_z3950_name , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_oid , BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { &hf_z3950_description , BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_instructions , BER_CLASS_CON, 6, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_EXTERNAL }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ProcessingInformation(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + ProcessingInformation_sequence, hf_index, ett_z3950_ProcessingInformation); + + return offset; +} + + +static const value_string z3950_ValueDescription_vals[] = { + { 0, "integer" }, + { 1, "string" }, + { 2, "octets" }, + { 3, "oid" }, + { 4, "unit" }, + { 5, "valueAndUnit" }, + { 0, NULL } +}; + +static const ber_choice_t ValueDescription_choice[] = { + { 0, &hf_z3950_integer , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_z3950_INTEGER }, + { 1, &hf_z3950_string , BER_CLASS_UNI, BER_UNI_TAG_GeneralString, BER_FLAGS_NOOWNTAG, dissect_z3950_InternationalString }, + { 2, &hf_z3950_octets , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_z3950_OCTET_STRING }, + { 3, &hf_z3950_oid , BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { 4, &hf_z3950_valueDescription_unit, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_Unit }, + { 5, &hf_z3950_valueAndUnit , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_IntUnit }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ValueDescription(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + ValueDescription_choice, hf_index, ett_z3950_ValueDescription, + NULL); + + return offset; +} + + +static const ber_sequence_t ValueRange_sequence[] = { + { &hf_z3950_lower , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_NOTCHKTAG, dissect_z3950_ValueDescription }, + { &hf_z3950_upper , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_NOTCHKTAG, dissect_z3950_ValueDescription }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ValueRange(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + ValueRange_sequence, hf_index, ett_z3950_ValueRange); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_ValueDescription_sequence_of[1] = { + { &hf_z3950_enumerated_item, BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_ValueDescription }, +}; + +static int +dissect_z3950_SEQUENCE_OF_ValueDescription(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_ValueDescription_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_ValueDescription); + + return offset; +} + + +static const value_string z3950_ValueSet_vals[] = { + { 0, "range" }, + { 1, "enumerated" }, + { 0, NULL } +}; + +static const ber_choice_t ValueSet_choice[] = { + { 0, &hf_z3950_range , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_ValueRange }, + { 1, &hf_z3950_enumerated , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_ValueDescription }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ValueSet(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + ValueSet_choice, hf_index, ett_z3950_ValueSet, + NULL); + + return offset; +} + + +static const ber_sequence_t VariantValue_sequence[] = { + { &hf_z3950_dataType , BER_CLASS_CON, 0, 0, dissect_z3950_PrimitiveDataType }, + { &hf_z3950_values , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_NOTCHKTAG, dissect_z3950_ValueSet }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_VariantValue(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + VariantValue_sequence, hf_index, ett_z3950_VariantValue); + + return offset; +} + + +static const ber_sequence_t VariantType_sequence[] = { + { &hf_z3950_name , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_description , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_variantType , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_variantValue , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_VariantValue }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_VariantType(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + VariantType_sequence, hf_index, ett_z3950_VariantType); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_VariantType_sequence_of[1] = { + { &hf_z3950_variantTypes_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_VariantType }, +}; + +static int +dissect_z3950_SEQUENCE_OF_VariantType(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_VariantType_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_VariantType); + + return offset; +} + + +static const ber_sequence_t VariantClass_sequence[] = { + { &hf_z3950_name , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_description , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_variantClass , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_variantTypes , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_VariantType }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_VariantClass(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + VariantClass_sequence, hf_index, ett_z3950_VariantClass); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_VariantClass_sequence_of[1] = { + { &hf_z3950_variantSetInfo_variants_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_VariantClass }, +}; + +static int +dissect_z3950_SEQUENCE_OF_VariantClass(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_VariantClass_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_VariantClass); + + return offset; +} + + +static const ber_sequence_t VariantSetInfo_sequence[] = { + { &hf_z3950_commonInfo , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_CommonInfo }, + { &hf_z3950_variantSet , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { &hf_z3950_name , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_variantSetInfo_variants, BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_VariantClass }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_VariantSetInfo(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + VariantSetInfo_sequence, hf_index, ett_z3950_VariantSetInfo); + + return offset; +} + + +static const ber_sequence_t Units_sequence[] = { + { &hf_z3950_name , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_description , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_unit , BER_CLASS_CON, 2, BER_FLAGS_NOTCHKTAG, dissect_z3950_StringOrNumeric }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Units(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + Units_sequence, hf_index, ett_z3950_Units); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_Units_sequence_of[1] = { + { &hf_z3950_unitType_units_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_Units }, +}; + +static int +dissect_z3950_SEQUENCE_OF_Units(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_Units_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_Units); + + return offset; +} + + +static const ber_sequence_t UnitType_sequence[] = { + { &hf_z3950_name , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_description , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_unitType , BER_CLASS_CON, 2, BER_FLAGS_NOTCHKTAG, dissect_z3950_StringOrNumeric }, + { &hf_z3950_unitType_units, BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_Units }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_UnitType(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + UnitType_sequence, hf_index, ett_z3950_UnitType); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_UnitType_sequence_of[1] = { + { &hf_z3950_unitInfo_units_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_UnitType }, +}; + +static int +dissect_z3950_SEQUENCE_OF_UnitType(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_UnitType_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_UnitType); + + return offset; +} + + +static const ber_sequence_t UnitInfo_sequence[] = { + { &hf_z3950_commonInfo , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_CommonInfo }, + { &hf_z3950_unitSystem , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_description , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_unitInfo_units, BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_UnitType }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_UnitInfo(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + UnitInfo_sequence, hf_index, ett_z3950_UnitInfo); + + return offset; +} + + +static const ber_sequence_t CategoryInfo_sequence[] = { + { &hf_z3950_categoryInfo_category, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_originalCategory, BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_description , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_HumanString }, + { &hf_z3950_asn1Module , BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_CategoryInfo(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + CategoryInfo_sequence, hf_index, ett_z3950_CategoryInfo); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_CategoryInfo_sequence_of[1] = { + { &hf_z3950_categories_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_CategoryInfo }, +}; + +static int +dissect_z3950_SEQUENCE_OF_CategoryInfo(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_CategoryInfo_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_CategoryInfo); + + return offset; +} + + +static const ber_sequence_t CategoryList_sequence[] = { + { &hf_z3950_commonInfo , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_CommonInfo }, + { &hf_z3950_categories , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_CategoryInfo }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_CategoryList(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + CategoryList_sequence, hf_index, ett_z3950_CategoryList); + + return offset; +} + + +static const value_string z3950_Explain_Record_vals[] = { + { 0, "targetInfo" }, + { 1, "databaseInfo" }, + { 2, "schemaInfo" }, + { 3, "tagSetInfo" }, + { 4, "recordSyntaxInfo" }, + { 5, "attributeSetInfo" }, + { 6, "termListInfo" }, + { 7, "extendedServicesInfo" }, + { 8, "attributeDetails" }, + { 9, "termListDetails" }, + { 10, "elementSetDetails" }, + { 11, "retrievalRecordDetails" }, + { 12, "sortDetails" }, + { 13, "processing" }, + { 14, "variants" }, + { 15, "units" }, + { 100, "categoryList" }, + { 0, NULL } +}; + +static const ber_choice_t Explain_Record_choice[] = { + { 0, &hf_z3950_targetInfo , BER_CLASS_CON, 0, BER_FLAGS_IMPLTAG, dissect_z3950_TargetInfo }, + { 1, &hf_z3950_databaseInfo , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_DatabaseInfo }, + { 2, &hf_z3950_schemaInfo , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_SchemaInfo }, + { 3, &hf_z3950_tagSetInfo , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_TagSetInfo }, + { 4, &hf_z3950_recordSyntaxInfo, BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_z3950_RecordSyntaxInfo }, + { 5, &hf_z3950_attributeSetInfo, BER_CLASS_CON, 5, BER_FLAGS_IMPLTAG, dissect_z3950_AttributeSetInfo }, + { 6, &hf_z3950_termListInfo , BER_CLASS_CON, 6, BER_FLAGS_IMPLTAG, dissect_z3950_TermListInfo }, + { 7, &hf_z3950_extendedServicesInfo, BER_CLASS_CON, 7, BER_FLAGS_IMPLTAG, dissect_z3950_ExtendedServicesInfo }, + { 8, &hf_z3950_attributeDetails, BER_CLASS_CON, 8, BER_FLAGS_IMPLTAG, dissect_z3950_AttributeDetails }, + { 9, &hf_z3950_termListDetails, BER_CLASS_CON, 9, BER_FLAGS_IMPLTAG, dissect_z3950_TermListDetails }, + { 10, &hf_z3950_elementSetDetails, BER_CLASS_CON, 10, BER_FLAGS_IMPLTAG, dissect_z3950_ElementSetDetails }, + { 11, &hf_z3950_retrievalRecordDetails, BER_CLASS_CON, 11, BER_FLAGS_IMPLTAG, dissect_z3950_RetrievalRecordDetails }, + { 12, &hf_z3950_sortDetails , BER_CLASS_CON, 12, BER_FLAGS_IMPLTAG, dissect_z3950_SortDetails }, + { 13, &hf_z3950_processing , BER_CLASS_CON, 13, BER_FLAGS_IMPLTAG, dissect_z3950_ProcessingInformation }, + { 14, &hf_z3950_variants , BER_CLASS_CON, 14, BER_FLAGS_IMPLTAG, dissect_z3950_VariantSetInfo }, + { 15, &hf_z3950_units , BER_CLASS_CON, 15, BER_FLAGS_IMPLTAG, dissect_z3950_UnitInfo }, + { 100, &hf_z3950_categoryList , BER_CLASS_CON, 100, BER_FLAGS_IMPLTAG, dissect_z3950_CategoryList }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Explain_Record(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + Explain_Record_choice, hf_index, ett_z3950_Explain_Record, + NULL); + + return offset; +} + + +static const ber_sequence_t FormatSpec_sequence[] = { + { &hf_z3950_formatSpec_type, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_size , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_bestPosn , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_FormatSpec(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + FormatSpec_sequence, hf_index, ett_z3950_FormatSpec); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_FormatSpec_sequence_of[1] = { + { &hf_z3950_briefBib_format_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_FormatSpec }, +}; + +static int +dissect_z3950_SEQUENCE_OF_FormatSpec(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_FormatSpec_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_FormatSpec); + + return offset; +} + + +static const ber_sequence_t BriefBib_sequence[] = { + { &hf_z3950_briefBib_title, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_author , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_callNumber , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_recordType , BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_bibliographicLevel, BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_briefBib_format, BER_CLASS_CON, 6, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_FormatSpec }, + { &hf_z3950_publicationPlace, BER_CLASS_CON, 7, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_publicationDate, BER_CLASS_CON, 8, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_targetSystemKey, BER_CLASS_CON, 9, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_satisfyingElement, BER_CLASS_CON, 10, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_rank , BER_CLASS_CON, 11, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_documentId , BER_CLASS_CON, 12, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_abstract , BER_CLASS_CON, 13, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_otherInfo , BER_CLASS_CON, 201, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG, dissect_z3950_OtherInformation }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_BriefBib(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + BriefBib_sequence, hf_index, ett_z3950_BriefBib); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_TaggedElement_sequence_of[1] = { + { &hf_z3950_subtree_item , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_TaggedElement }, +}; + +static int +dissect_z3950_SEQUENCE_OF_TaggedElement(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_TaggedElement_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_TaggedElement); + + return offset; +} + + +static const value_string z3950_ElementData_vals[] = { + { 0, "octets" }, + { 1, "numeric" }, + { 2, "date" }, + { 3, "ext" }, + { 4, "string" }, + { 5, "trueOrFalse" }, + { 6, "oid" }, + { 7, "intUnit" }, + { 8, "elementNotThere" }, + { 9, "elementEmpty" }, + { 10, "noDataRequested" }, + { 11, "diagnostic" }, + { 12, "subtree" }, + { 0, NULL } +}; + +static const ber_choice_t ElementData_choice[] = { + { 0, &hf_z3950_octets , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_z3950_OCTET_STRING }, + { 1, &hf_z3950_numeric , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_z3950_INTEGER }, + { 2, &hf_z3950_date , BER_CLASS_UNI, BER_UNI_TAG_GeneralizedTime, BER_FLAGS_NOOWNTAG, dissect_z3950_GeneralizedTime }, + { 3, &hf_z3950_ext , BER_CLASS_UNI, BER_UNI_TAG_EXTERNAL, BER_FLAGS_NOOWNTAG, dissect_z3950_EXTERNAL }, + { 4, &hf_z3950_string , BER_CLASS_UNI, BER_UNI_TAG_GeneralString, BER_FLAGS_NOOWNTAG, dissect_z3950_InternationalString }, + { 5, &hf_z3950_trueOrFalse , BER_CLASS_UNI, BER_UNI_TAG_BOOLEAN, BER_FLAGS_NOOWNTAG, dissect_z3950_BOOLEAN }, + { 6, &hf_z3950_oid , BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { 7, &hf_z3950_intUnit , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_IntUnit }, + { 8, &hf_z3950_elementNotThere, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 9, &hf_z3950_elementEmpty , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 10, &hf_z3950_noDataRequested, BER_CLASS_CON, 4, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 11, &hf_z3950_elementData_diagnostic, BER_CLASS_CON, 5, BER_FLAGS_IMPLTAG, dissect_z3950_EXTERNAL }, + { 12, &hf_z3950_subtree , BER_CLASS_CON, 6, 0, dissect_z3950_SEQUENCE_OF_TaggedElement }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ElementData(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + ElementData_choice, hf_index, ett_z3950_ElementData, + NULL); + + return offset; +} + + +static const ber_sequence_t Order_sequence[] = { + { &hf_z3950_ascending , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_order , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Order(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + Order_sequence, hf_index, ett_z3950_Order); + + return offset; +} + + +static const value_string z3950_T_usage_type_vals[] = { + { 1, "redistributable" }, + { 2, "restricted" }, + { 3, "licensePointer" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_usage_type(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const ber_sequence_t Usage_sequence[] = { + { &hf_z3950_usage_type , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_T_usage_type }, + { &hf_z3950_restriction , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Usage(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + Usage_sequence, hf_index, ett_z3950_Usage); + + return offset; +} + + +static const ber_sequence_t HitVector_sequence[] = { + { &hf_z3950_satisfier , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_OPTIONAL|BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_z3950_Term }, + { &hf_z3950_offsetIntoElement, BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_IntUnit }, + { &hf_z3950_length , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_IntUnit }, + { &hf_z3950_hitRank , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_targetToken , BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_OCTET_STRING }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_HitVector(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + HitVector_sequence, hf_index, ett_z3950_HitVector); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_HitVector_sequence_of[1] = { + { &hf_z3950_hits_item , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_HitVector }, +}; + +static int +dissect_z3950_SEQUENCE_OF_HitVector(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_HitVector_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_HitVector); + + return offset; +} + + +static const value_string z3950_T_variant_triples_item_value_vals[] = { + { 0, "integer" }, + { 1, "string" }, + { 2, "octetString" }, + { 3, "oid" }, + { 4, "boolean" }, + { 5, "null" }, + { 6, "unit" }, + { 7, "valueAndUnit" }, + { 0, NULL } +}; + +static const ber_choice_t T_variant_triples_item_value_choice[] = { + { 0, &hf_z3950_integer , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_z3950_INTEGER }, + { 1, &hf_z3950_string , BER_CLASS_UNI, BER_UNI_TAG_GeneralString, BER_FLAGS_NOOWNTAG, dissect_z3950_InternationalString }, + { 2, &hf_z3950_octetString , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_z3950_OCTET_STRING }, + { 3, &hf_z3950_oid , BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { 4, &hf_z3950_boolean , BER_CLASS_UNI, BER_UNI_TAG_BOOLEAN, BER_FLAGS_NOOWNTAG, dissect_z3950_BOOLEAN }, + { 5, &hf_z3950_null , BER_CLASS_UNI, BER_UNI_TAG_NULL, BER_FLAGS_NOOWNTAG, dissect_z3950_NULL }, + { 6, &hf_z3950_variant_triples_item_value_unit, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_Unit }, + { 7, &hf_z3950_valueAndUnit , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_IntUnit }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_variant_triples_item_value(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_variant_triples_item_value_choice, hf_index, ett_z3950_T_variant_triples_item_value, + NULL); + + return offset; +} + + +static const ber_sequence_t T_triples_item_sequence[] = { + { &hf_z3950_variantSetId , BER_CLASS_CON, 0, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { &hf_z3950_class , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_type , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_variant_triples_item_value, BER_CLASS_CON, 3, 0, dissect_z3950_T_variant_triples_item_value }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_triples_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_triples_item_sequence, hf_index, ett_z3950_T_triples_item); + + return offset; +} + + +static const ber_sequence_t T_triples_sequence_of[1] = { + { &hf_z3950_triples_item , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_T_triples_item }, +}; + +static int +dissect_z3950_T_triples(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + T_triples_sequence_of, hf_index, ett_z3950_T_triples); + + return offset; +} + + +static const ber_sequence_t Variant_sequence[] = { + { &hf_z3950_globalVariantSetId, BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { &hf_z3950_triples , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_T_triples }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Variant(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + Variant_sequence, hf_index, ett_z3950_Variant); + + return offset; +} + + +static const ber_sequence_t SEQUENCE_OF_Variant_sequence_of[1] = { + { &hf_z3950_supportedVariants_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_Variant }, +}; + +static int +dissect_z3950_SEQUENCE_OF_Variant(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SEQUENCE_OF_Variant_sequence_of, hf_index, ett_z3950_SEQUENCE_OF_Variant); + + return offset; +} + + +static const ber_sequence_t TagPath_item_sequence[] = { + { &hf_z3950_tagType , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_tagValue , BER_CLASS_CON, 2, BER_FLAGS_NOTCHKTAG, dissect_z3950_StringOrNumeric }, + { &hf_z3950_tagOccurrence , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_TagPath_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + TagPath_item_sequence, hf_index, ett_z3950_TagPath_item); + + return offset; +} + + +static const ber_sequence_t TagPath_sequence_of[1] = { + { &hf_z3950_TagPath_item , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_TagPath_item }, +}; + +static int +dissect_z3950_TagPath(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + TagPath_sequence_of, hf_index, ett_z3950_TagPath); + + return offset; +} + + +static const ber_sequence_t ElementMetaData_sequence[] = { + { &hf_z3950_seriesOrder , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_Order }, + { &hf_z3950_usageRight , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_Usage }, + { &hf_z3950_hits , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_HitVector }, + { &hf_z3950_displayName , BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_supportedVariants, BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_Variant }, + { &hf_z3950_message , BER_CLASS_CON, 6, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_elementDescriptor, BER_CLASS_CON, 7, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_OCTET_STRING }, + { &hf_z3950_surrogateFor , BER_CLASS_CON, 8, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_TagPath }, + { &hf_z3950_surrogateElement, BER_CLASS_CON, 9, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_TagPath }, + { &hf_z3950_other , BER_CLASS_CON, 99, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_EXTERNAL }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ElementMetaData(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + ElementMetaData_sequence, hf_index, ett_z3950_ElementMetaData); + + return offset; +} + + +static const ber_sequence_t TaggedElement_sequence[] = { + { &hf_z3950_tagType , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_tagValue , BER_CLASS_CON, 2, BER_FLAGS_NOTCHKTAG, dissect_z3950_StringOrNumeric }, + { &hf_z3950_tagOccurrence , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_taggedElement_content, BER_CLASS_CON, 4, BER_FLAGS_NOTCHKTAG, dissect_z3950_ElementData }, + { &hf_z3950_metaData , BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_ElementMetaData }, + { &hf_z3950_appliedVariant, BER_CLASS_CON, 6, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_Variant }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_TaggedElement(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + TaggedElement_sequence, hf_index, ett_z3950_TaggedElement); + + return offset; +} + + +static const ber_sequence_t GenericRecord_sequence_of[1] = { + { &hf_z3950_GenericRecord_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_TaggedElement }, +}; + +static int +dissect_z3950_GenericRecord(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + GenericRecord_sequence_of, hf_index, ett_z3950_GenericRecord); + + return offset; +} + + +static const value_string z3950_T_taskStatus_vals[] = { + { 0, "pending" }, + { 1, "active" }, + { 2, "complete" }, + { 3, "aborted" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_taskStatus(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const ber_sequence_t TaskPackage_sequence[] = { + { &hf_z3950_packageType , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_OBJECT_IDENTIFIER }, + { &hf_z3950_packageName , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_userId , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_retentionTime , BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_IntUnit }, + { &hf_z3950_permissions , BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_Permissions }, + { &hf_z3950_taskPackage_description, BER_CLASS_CON, 6, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_targetReference, BER_CLASS_CON, 7, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_OCTET_STRING }, + { &hf_z3950_creationDateTime, BER_CLASS_CON, 8, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_GeneralizedTime }, + { &hf_z3950_taskStatus , BER_CLASS_CON, 9, BER_FLAGS_IMPLTAG, dissect_z3950_T_taskStatus }, + { &hf_z3950_packageDiagnostics, BER_CLASS_CON, 10, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_DiagRec }, + { &hf_z3950_taskSpecificParameters, BER_CLASS_CON, 11, BER_FLAGS_IMPLTAG, dissect_z3950_EXTERNAL }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_TaskPackage(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + TaskPackage_sequence, hf_index, ett_z3950_TaskPackage); + + return offset; +} + + +static const value_string z3950_T_promptId_enummeratedPrompt_type_vals[] = { + { 0, "groupId" }, + { 1, "userId" }, + { 2, "password" }, + { 3, "newPassword" }, + { 4, "copyright" }, + { 5, "sessionId" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_promptId_enummeratedPrompt_type(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const ber_sequence_t T_enummeratedPrompt_sequence[] = { + { &hf_z3950_promptId_enummeratedPrompt_type, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_T_promptId_enummeratedPrompt_type }, + { &hf_z3950_suggestedString, BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_enummeratedPrompt(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_enummeratedPrompt_sequence, hf_index, ett_z3950_T_enummeratedPrompt); + + return offset; +} + + +static const value_string z3950_PromptId_vals[] = { + { 1, "enummeratedPrompt" }, + { 2, "nonEnumeratedPrompt" }, + { 0, NULL } +}; + +static const ber_choice_t PromptId_choice[] = { + { 1, &hf_z3950_enummeratedPrompt, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_T_enummeratedPrompt }, + { 2, &hf_z3950_nonEnumeratedPrompt, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_PromptId(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + PromptId_choice, hf_index, ett_z3950_PromptId, + NULL); + + return offset; +} + + +static const ber_sequence_t Encryption_sequence[] = { + { &hf_z3950_cryptType , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_OCTET_STRING }, + { &hf_z3950_credential , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_OCTET_STRING }, + { &hf_z3950_data , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_OCTET_STRING }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Encryption(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + Encryption_sequence, hf_index, ett_z3950_Encryption); + + return offset; +} + + +static const value_string z3950_T_promptInfo_vals[] = { + { 1, "character" }, + { 2, "encrypted" }, + { 0, NULL } +}; + +static const ber_choice_t T_promptInfo_choice[] = { + { 1, &hf_z3950_challenge_item_promptInfo_character, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { 2, &hf_z3950_encrypted , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_Encryption }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_promptInfo(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_promptInfo_choice, hf_index, ett_z3950_T_promptInfo, + NULL); + + return offset; +} + + +static const value_string z3950_T_challenge_item_dataType_vals[] = { + { 1, "integer" }, + { 2, "date" }, + { 3, "float" }, + { 4, "alphaNumeric" }, + { 5, "url-urn" }, + { 6, "boolean" }, + { 0, NULL } +}; + + +static int +dissect_z3950_T_challenge_item_dataType(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index, + NULL); + + return offset; +} + + +static const ber_sequence_t Challenge_item_sequence[] = { + { &hf_z3950_promptId , BER_CLASS_CON, 1, BER_FLAGS_NOTCHKTAG, dissect_z3950_PromptId }, + { &hf_z3950_defaultResponse, BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_promptInfo , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL, dissect_z3950_T_promptInfo }, + { &hf_z3950_regExpr , BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_responseRequired, BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { &hf_z3950_allowedValues , BER_CLASS_CON, 6, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_InternationalString }, + { &hf_z3950_shouldSave , BER_CLASS_CON, 7, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { &hf_z3950_challenge_item_dataType, BER_CLASS_CON, 8, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_T_challenge_item_dataType }, + { &hf_z3950_challenge_item_diagnostic, BER_CLASS_CON, 9, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_EXTERNAL }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Challenge_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + Challenge_item_sequence, hf_index, ett_z3950_Challenge_item); + + return offset; +} + + +static const ber_sequence_t Challenge_sequence_of[1] = { + { &hf_z3950_Challenge_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_Challenge_item }, +}; + +static int +dissect_z3950_Challenge(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + Challenge_sequence_of, hf_index, ett_z3950_Challenge); + + return offset; +} + + +static const value_string z3950_T_promptResponse_vals[] = { + { 1, "string" }, + { 2, "accept" }, + { 3, "acknowledge" }, + { 4, "diagnostic" }, + { 5, "encrypted" }, + { 0, NULL } +}; + +static const ber_choice_t T_promptResponse_choice[] = { + { 1, &hf_z3950_string , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { 2, &hf_z3950_accept , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { 3, &hf_z3950_acknowledge , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 4, &hf_z3950_diagnostic , BER_CLASS_CON, 4, 0, dissect_z3950_DiagRec }, + { 5, &hf_z3950_encrypted , BER_CLASS_CON, 5, BER_FLAGS_IMPLTAG, dissect_z3950_Encryption }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_promptResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_promptResponse_choice, hf_index, ett_z3950_T_promptResponse, + NULL); + + return offset; +} + + +static const ber_sequence_t Response_item_sequence[] = { + { &hf_z3950_promptId , BER_CLASS_CON, 1, BER_FLAGS_NOTCHKTAG, dissect_z3950_PromptId }, + { &hf_z3950_promptResponse, BER_CLASS_CON, 2, 0, dissect_z3950_T_promptResponse }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_Response_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + Response_item_sequence, hf_index, ett_z3950_Response_item); + + return offset; +} + + +static const ber_sequence_t Response_sequence_of[1] = { + { &hf_z3950_Response_item , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_Response_item }, +}; + +static int +dissect_z3950_Response(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + Response_sequence_of, hf_index, ett_z3950_Response); + + return offset; +} + + +static const value_string z3950_PromptObject_vals[] = { + { 1, "challenge" }, + { 2, "response" }, + { 0, NULL } +}; + +static const ber_choice_t PromptObject_choice[] = { + { 1, &hf_z3950_challenge , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_Challenge }, + { 2, &hf_z3950_response , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_Response }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_PromptObject(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + PromptObject_choice, hf_index, ett_z3950_PromptObject, + NULL); + + return offset; +} + + +static const ber_sequence_t DRNType_sequence[] = { + { &hf_z3950_dRNType_userId, BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_OCTET_STRING }, + { &hf_z3950_salt , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_OCTET_STRING }, + { &hf_z3950_randomNumber , BER_CLASS_CON, 3, BER_FLAGS_IMPLTAG, dissect_z3950_OCTET_STRING }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_DRNType(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + DRNType_sequence, hf_index, ett_z3950_DRNType); + + return offset; +} + + +static const value_string z3950_DES_RN_Object_vals[] = { + { 1, "challenge" }, + { 2, "response" }, + { 0, NULL } +}; + +static const ber_choice_t DES_RN_Object_choice[] = { + { 1, &hf_z3950_dES_RN_Object_challenge, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_DRNType }, + { 2, &hf_z3950_rES_RN_Object_response, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_DRNType }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_DES_RN_Object(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + DES_RN_Object_choice, hf_index, ett_z3950_DES_RN_Object, + NULL); + + return offset; +} + + +static const ber_sequence_t KRBRequest_sequence[] = { + { &hf_z3950_service , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_instance , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_realm , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_KRBRequest(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + KRBRequest_sequence, hf_index, ett_z3950_KRBRequest); + + return offset; +} + + +static const ber_sequence_t KRBResponse_sequence[] = { + { &hf_z3950_userid , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_ticket , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_OCTET_STRING }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_KRBResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + KRBResponse_sequence, hf_index, ett_z3950_KRBResponse); + + return offset; +} + + +static const value_string z3950_KRBObject_vals[] = { + { 1, "challenge" }, + { 2, "response" }, + { 0, NULL } +}; + +static const ber_choice_t KRBObject_choice[] = { + { 1, &hf_z3950_kRBObject_challenge, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_KRBRequest }, + { 2, &hf_z3950_kRBObject_response, BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_KRBResponse }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_KRBObject(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + KRBObject_choice, hf_index, ett_z3950_KRBObject, + NULL); + + return offset; +} + + +static const ber_sequence_t T_queryExpression_term_sequence[] = { + { &hf_z3950_queryTerm , BER_CLASS_CON, 1, BER_FLAGS_NOTCHKTAG, dissect_z3950_Term }, + { &hf_z3950_termComment , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_queryExpression_term(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + T_queryExpression_term_sequence, hf_index, ett_z3950_T_queryExpression_term); + + return offset; +} + + +static const value_string z3950_QueryExpression_vals[] = { + { 1, "term" }, + { 2, "query" }, + { 0, NULL } +}; + +static const ber_choice_t QueryExpression_choice[] = { + { 1, &hf_z3950_queryExpression_term, BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_T_queryExpression_term }, + { 2, &hf_z3950_query , BER_CLASS_CON, 2, 0, dissect_z3950_Query }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_QueryExpression(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + QueryExpression_choice, hf_index, ett_z3950_QueryExpression, + NULL); + + return offset; +} + + +static const value_string z3950_T_databases_vals[] = { + { 1, "all" }, + { 2, "list" }, + { 0, NULL } +}; + +static const ber_choice_t T_databases_choice[] = { + { 1, &hf_z3950_all , BER_CLASS_CON, 1, BER_FLAGS_IMPLTAG, dissect_z3950_NULL }, + { 2, &hf_z3950_list , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_SEQUENCE_OF_DatabaseName }, + { 0, NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_T_databases(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_choice(actx, tree, tvb, offset, + T_databases_choice, hf_index, ett_z3950_T_databases, + NULL); + + return offset; +} + + +static const ber_sequence_t ResultsByDB_item_sequence[] = { + { &hf_z3950_databases , BER_CLASS_CON, 1, 0, dissect_z3950_T_databases }, + { &hf_z3950_count , BER_CLASS_CON, 2, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_resultSetName , BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_ResultsByDB_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + ResultsByDB_item_sequence, hf_index, ett_z3950_ResultsByDB_item); + + return offset; +} + + +static const ber_sequence_t ResultsByDB_sequence_of[1] = { + { &hf_z3950_ResultsByDB_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_ResultsByDB_item }, +}; + +static int +dissect_z3950_ResultsByDB(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + ResultsByDB_sequence_of, hf_index, ett_z3950_ResultsByDB); + + return offset; +} + + +static const ber_sequence_t SearchInfoReport_item_sequence[] = { + { &hf_z3950_subqueryId , BER_CLASS_CON, 1, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_InternationalString }, + { &hf_z3950_fullQuery , BER_CLASS_CON, 2, BER_FLAGS_IMPLTAG, dissect_z3950_BOOLEAN }, + { &hf_z3950_subqueryExpression, BER_CLASS_CON, 3, BER_FLAGS_OPTIONAL|BER_FLAGS_NOTCHKTAG, dissect_z3950_QueryExpression }, + { &hf_z3950_subqueryInterpretation, BER_CLASS_CON, 4, BER_FLAGS_OPTIONAL|BER_FLAGS_NOTCHKTAG, dissect_z3950_QueryExpression }, + { &hf_z3950_subqueryRecommendation, BER_CLASS_CON, 5, BER_FLAGS_OPTIONAL|BER_FLAGS_NOTCHKTAG, dissect_z3950_QueryExpression }, + { &hf_z3950_subqueryCount , BER_CLASS_CON, 6, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_INTEGER }, + { &hf_z3950_subqueryWeight, BER_CLASS_CON, 7, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_IntUnit }, + { &hf_z3950_resultsByDB , BER_CLASS_CON, 8, BER_FLAGS_OPTIONAL|BER_FLAGS_IMPLTAG, dissect_z3950_ResultsByDB }, + { NULL, 0, 0, 0, NULL } +}; + +static int +dissect_z3950_SearchInfoReport_item(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset, + SearchInfoReport_item_sequence, hf_index, ett_z3950_SearchInfoReport_item); + + return offset; +} + + +static const ber_sequence_t SearchInfoReport_sequence_of[1] = { + { &hf_z3950_SearchInfoReport_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_z3950_SearchInfoReport_item }, +}; + +static int +dissect_z3950_SearchInfoReport(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) { + offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset, + SearchInfoReport_sequence_of, hf_index, ett_z3950_SearchInfoReport); + + return offset; +} + +/*--- PDUs ---*/ + +static int dissect_OCLC_UserInformation_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void *data _U_) { + int offset = 0; + asn1_ctx_t asn1_ctx; + asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo); + offset = dissect_z3950_OCLC_UserInformation(FALSE, tvb, offset, &asn1_ctx, tree, hf_z3950_OCLC_UserInformation_PDU); + return offset; +} +static int dissect_SutrsRecord_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void *data _U_) { + int offset = 0; + asn1_ctx_t asn1_ctx; + asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo); + offset = dissect_z3950_SutrsRecord(FALSE, tvb, offset, &asn1_ctx, tree, hf_z3950_SutrsRecord_PDU); + return offset; +} +static int dissect_OPACRecord_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void *data _U_) { + int offset = 0; + asn1_ctx_t asn1_ctx; + asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo); + offset = dissect_z3950_OPACRecord(FALSE, tvb, offset, &asn1_ctx, tree, hf_z3950_OPACRecord_PDU); + return offset; +} +static int dissect_DiagnosticFormat_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void *data _U_) { + int offset = 0; + asn1_ctx_t asn1_ctx; + asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo); + offset = dissect_z3950_DiagnosticFormat(FALSE, tvb, offset, &asn1_ctx, tree, hf_z3950_DiagnosticFormat_PDU); + return offset; +} +static int dissect_Explain_Record_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void *data _U_) { + int offset = 0; + asn1_ctx_t asn1_ctx; + asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo); + offset = dissect_z3950_Explain_Record(FALSE, tvb, offset, &asn1_ctx, tree, hf_z3950_Explain_Record_PDU); + return offset; +} +static int dissect_BriefBib_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void *data _U_) { + int offset = 0; + asn1_ctx_t asn1_ctx; + asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo); + offset = dissect_z3950_BriefBib(FALSE, tvb, offset, &asn1_ctx, tree, hf_z3950_BriefBib_PDU); + return offset; +} +static int dissect_GenericRecord_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void *data _U_) { + int offset = 0; + asn1_ctx_t asn1_ctx; + asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo); + offset = dissect_z3950_GenericRecord(FALSE, tvb, offset, &asn1_ctx, tree, hf_z3950_GenericRecord_PDU); + return offset; +} +static int dissect_TaskPackage_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void *data _U_) { + int offset = 0; + asn1_ctx_t asn1_ctx; + asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo); + offset = dissect_z3950_TaskPackage(FALSE, tvb, offset, &asn1_ctx, tree, hf_z3950_TaskPackage_PDU); + return offset; +} +static int dissect_PromptObject_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void *data _U_) { + int offset = 0; + asn1_ctx_t asn1_ctx; + asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo); + offset = dissect_z3950_PromptObject(FALSE, tvb, offset, &asn1_ctx, tree, hf_z3950_PromptObject_PDU); + return offset; +} +static int dissect_DES_RN_Object_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void *data _U_) { + int offset = 0; + asn1_ctx_t asn1_ctx; + asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo); + offset = dissect_z3950_DES_RN_Object(FALSE, tvb, offset, &asn1_ctx, tree, hf_z3950_DES_RN_Object_PDU); + return offset; +} +static int dissect_KRBObject_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void *data _U_) { + int offset = 0; + asn1_ctx_t asn1_ctx; + asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo); + offset = dissect_z3950_KRBObject(FALSE, tvb, offset, &asn1_ctx, tree, hf_z3950_KRBObject_PDU); + return offset; +} +static int dissect_SearchInfoReport_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void *data _U_) { + int offset = 0; + asn1_ctx_t asn1_ctx; + asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo); + offset = dissect_z3950_SearchInfoReport(FALSE, tvb, offset, &asn1_ctx, tree, hf_z3950_SearchInfoReport_PDU); + return offset; +} + + +/*--- End of included file: packet-z3950-fn.c ---*/ +#line 925 "./asn1/z3950/packet-z3950-template.c" + +static int +dissect_z3950(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_) +{ + proto_item *z3950_item = NULL; + proto_tree *z3950_tree = NULL; + int offset = 0; + asn1_ctx_t asn1_ctx; + asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo); + + + /* make entry in the Protocol column on summary display */ + col_set_str(pinfo->cinfo, COL_PROTOCOL, PSNAME); + + /* create the z3950 protocol tree */ + z3950_item = proto_tree_add_item(tree, proto_z3950, tvb, 0, -1, FALSE); + z3950_tree = proto_item_add_subtree(z3950_item, ett_z3950); + + return dissect_z3950_PDU(FALSE, tvb, offset, &asn1_ctx, z3950_tree, -1); +} + +static guint +get_z3950_pdu_len(packet_info *pinfo _U_, tvbuff_t *tvb, int offset, void *data _U_) +{ + guint plen; + guint ber_offset; + TRY { + /* Skip past identifier */ + ber_offset = get_ber_identifier(tvb, offset, NULL, NULL, NULL); + ber_offset = get_ber_length(tvb, ber_offset, &plen, NULL); + plen += (ber_offset - offset); + } + CATCH(ReportedBoundsError) { + plen = 0; + } + ENDTRY; + + return plen; +} + +static int +dissect_z3950_segment(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void * data _U_) +{ + + /* Min length of 8 assumes 3 for identifer and 5 for length. */ + tcp_dissect_pdus(tvb, pinfo, tree, z3950_desegment, 8, get_z3950_pdu_len, dissect_z3950, data); + return tvb_captured_length(tvb); +} + +/*--- proto_register_z3950 -------------------------------------------*/ +void proto_register_z3950(void) { + + /* List of fields */ + static hf_register_info hf[] = { + + +/*--- Included file: packet-z3950-hfarr.c ---*/ +#line 1 "./asn1/z3950/packet-z3950-hfarr.c" + { &hf_z3950_OCLC_UserInformation_PDU, + { "OCLC-UserInformation", "z3950.OCLC_UserInformation_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_SutrsRecord_PDU, + { "SutrsRecord", "z3950.SutrsRecord", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_OPACRecord_PDU, + { "OPACRecord", "z3950.OPACRecord_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_DiagnosticFormat_PDU, + { "DiagnosticFormat", "z3950.DiagnosticFormat", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_Explain_Record_PDU, + { "Explain-Record", "z3950.Explain_Record", + FT_UINT32, BASE_DEC, VALS(z3950_Explain_Record_vals), 0, + NULL, HFILL }}, + { &hf_z3950_BriefBib_PDU, + { "BriefBib", "z3950.BriefBib_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_GenericRecord_PDU, + { "GenericRecord", "z3950.GenericRecord", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_TaskPackage_PDU, + { "TaskPackage", "z3950.TaskPackage_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_PromptObject_PDU, + { "PromptObject", "z3950.PromptObject", + FT_UINT32, BASE_DEC, VALS(z3950_PromptObject_vals), 0, + NULL, HFILL }}, + { &hf_z3950_DES_RN_Object_PDU, + { "DES-RN-Object", "z3950.DES_RN_Object", + FT_UINT32, BASE_DEC, VALS(z3950_DES_RN_Object_vals), 0, + NULL, HFILL }}, + { &hf_z3950_KRBObject_PDU, + { "KRBObject", "z3950.KRBObject", + FT_UINT32, BASE_DEC, VALS(z3950_KRBObject_vals), 0, + NULL, HFILL }}, + { &hf_z3950_SearchInfoReport_PDU, + { "SearchInfoReport", "z3950.SearchInfoReport", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_initRequest, + { "initRequest", "z3950.initRequest_element", + FT_NONE, BASE_NONE, NULL, 0, + "InitializeRequest", HFILL }}, + { &hf_z3950_initResponse, + { "initResponse", "z3950.initResponse_element", + FT_NONE, BASE_NONE, NULL, 0, + "InitializeResponse", HFILL }}, + { &hf_z3950_searchRequest, + { "searchRequest", "z3950.searchRequest_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_searchResponse, + { "searchResponse", "z3950.searchResponse_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_presentRequest, + { "presentRequest", "z3950.presentRequest_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_presentResponse, + { "presentResponse", "z3950.presentResponse_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_deleteResultSetRequest, + { "deleteResultSetRequest", "z3950.deleteResultSetRequest_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_deleteResultSetResponse, + { "deleteResultSetResponse", "z3950.deleteResultSetResponse_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_accessControlRequest, + { "accessControlRequest", "z3950.accessControlRequest_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_accessControlResponse, + { "accessControlResponse", "z3950.accessControlResponse_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_resourceControlRequest, + { "resourceControlRequest", "z3950.resourceControlRequest_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_resourceControlResponse, + { "resourceControlResponse", "z3950.resourceControlResponse_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_triggerResourceControlRequest, + { "triggerResourceControlRequest", "z3950.triggerResourceControlRequest_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_resourceReportRequest, + { "resourceReportRequest", "z3950.resourceReportRequest_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_resourceReportResponse, + { "resourceReportResponse", "z3950.resourceReportResponse_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_scanRequest, + { "scanRequest", "z3950.scanRequest_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_scanResponse, + { "scanResponse", "z3950.scanResponse_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_sortRequest, + { "sortRequest", "z3950.sortRequest_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_sortResponse, + { "sortResponse", "z3950.sortResponse_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_segmentRequest, + { "segmentRequest", "z3950.segmentRequest_element", + FT_NONE, BASE_NONE, NULL, 0, + "Segment", HFILL }}, + { &hf_z3950_extendedServicesRequest, + { "extendedServicesRequest", "z3950.extendedServicesRequest_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_extendedServicesResponse, + { "extendedServicesResponse", "z3950.extendedServicesResponse_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_close, + { "close", "z3950.close_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_referenceId, + { "referenceId", "z3950.referenceId", + FT_BYTES, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_protocolVersion, + { "protocolVersion", "z3950.protocolVersion", + FT_BYTES, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_options, + { "options", "z3950.options", + FT_BYTES, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_preferredMessageSize, + { "preferredMessageSize", "z3950.preferredMessageSize", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_exceptionalRecordSize, + { "exceptionalRecordSize", "z3950.exceptionalRecordSize", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_idAuthentication, + { "idAuthentication", "z3950.idAuthentication", + FT_UINT32, BASE_DEC, VALS(z3950_T_idAuthentication_vals), 0, + NULL, HFILL }}, + { &hf_z3950_open, + { "open", "z3950.open", + FT_STRING, BASE_NONE, NULL, 0, + "VisibleString", HFILL }}, + { &hf_z3950_idPass, + { "idPass", "z3950.idPass_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_groupId, + { "groupId", "z3950.groupId", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_userId, + { "userId", "z3950.userId", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_password, + { "password", "z3950.password", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_anonymous, + { "anonymous", "z3950.anonymous_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_other, + { "other", "z3950.other_element", + FT_NONE, BASE_NONE, NULL, 0, + "EXTERNAL", HFILL }}, + { &hf_z3950_implementationId, + { "implementationId", "z3950.implementationId", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_implementationName, + { "implementationName", "z3950.implementationName", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_implementationVersion, + { "implementationVersion", "z3950.implementationVersion", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_userInformationField, + { "userInformationField", "z3950.userInformationField_element", + FT_NONE, BASE_NONE, NULL, 0, + "EXTERNAL", HFILL }}, + { &hf_z3950_otherInfo, + { "otherInfo", "z3950.otherInfo", + FT_UINT32, BASE_DEC, NULL, 0, + "OtherInformation", HFILL }}, + { &hf_z3950_result, + { "result", "z3950.result", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_smallSetUpperBound, + { "smallSetUpperBound", "z3950.smallSetUpperBound", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_largeSetLowerBound, + { "largeSetLowerBound", "z3950.largeSetLowerBound", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_mediumSetPresentNumber, + { "mediumSetPresentNumber", "z3950.mediumSetPresentNumber", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_replaceIndicator, + { "replaceIndicator", "z3950.replaceIndicator", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_resultSetName, + { "resultSetName", "z3950.resultSetName", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_databaseNames, + { "databaseNames", "z3950.databaseNames", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_DatabaseName", HFILL }}, + { &hf_z3950_databaseNames_item, + { "DatabaseName", "z3950.DatabaseName", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_smallSetElementSetNames, + { "smallSetElementSetNames", "z3950.smallSetElementSetNames", + FT_UINT32, BASE_DEC, VALS(z3950_ElementSetNames_vals), 0, + "ElementSetNames", HFILL }}, + { &hf_z3950_mediumSetElementSetNames, + { "mediumSetElementSetNames", "z3950.mediumSetElementSetNames", + FT_UINT32, BASE_DEC, VALS(z3950_ElementSetNames_vals), 0, + "ElementSetNames", HFILL }}, + { &hf_z3950_preferredRecordSyntax, + { "preferredRecordSyntax", "z3950.preferredRecordSyntax", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_query, + { "query", "z3950.query", + FT_UINT32, BASE_DEC, VALS(z3950_Query_vals), 0, + NULL, HFILL }}, + { &hf_z3950_additionalSearchInfo, + { "additionalSearchInfo", "z3950.additionalSearchInfo", + FT_UINT32, BASE_DEC, NULL, 0, + "OtherInformation", HFILL }}, + { &hf_z3950_type_0, + { "type-0", "z3950.type_0_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_type_1, + { "type-1", "z3950.type_1_element", + FT_NONE, BASE_NONE, NULL, 0, + "RPNQuery", HFILL }}, + { &hf_z3950_type_2, + { "type-2", "z3950.type_2", + FT_BYTES, BASE_NONE, NULL, 0, + "OCTET_STRING", HFILL }}, + { &hf_z3950_type_100, + { "type-100", "z3950.type_100", + FT_BYTES, BASE_NONE, NULL, 0, + "OCTET_STRING", HFILL }}, + { &hf_z3950_type_101, + { "type-101", "z3950.type_101_element", + FT_NONE, BASE_NONE, NULL, 0, + "RPNQuery", HFILL }}, + { &hf_z3950_type_102, + { "type-102", "z3950.type_102", + FT_BYTES, BASE_NONE, NULL, 0, + "OCTET_STRING", HFILL }}, + { &hf_z3950_attributeSet, + { "attributeSet", "z3950.attributeSet", + FT_OID, BASE_NONE, NULL, 0, + "AttributeSetId", HFILL }}, + { &hf_z3950_rpn, + { "rpn", "z3950.rpn", + FT_UINT32, BASE_DEC, VALS(z3950_RPNStructure_vals), 0, + "RPNStructure", HFILL }}, + { &hf_z3950_operandRpnOp, + { "op", "z3950.op", + FT_UINT32, BASE_DEC, VALS(z3950_Operand_vals), 0, + "Operand", HFILL }}, + { &hf_z3950_rpnRpnOp, + { "rpnRpnOp", "z3950.rpnRpnOp_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_rpn1, + { "rpn1", "z3950.rpn1", + FT_UINT32, BASE_DEC, VALS(z3950_RPNStructure_vals), 0, + "RPNStructure", HFILL }}, + { &hf_z3950_rpn2, + { "rpn2", "z3950.rpn2", + FT_UINT32, BASE_DEC, VALS(z3950_RPNStructure_vals), 0, + "RPNStructure", HFILL }}, + { &hf_z3950_operatorRpnOp, + { "op", "z3950.op", + FT_UINT32, BASE_DEC, VALS(z3950_Operator_U_vals), 0, + "Operator", HFILL }}, + { &hf_z3950_attrTerm, + { "attrTerm", "z3950.attrTerm_element", + FT_NONE, BASE_NONE, NULL, 0, + "AttributesPlusTerm", HFILL }}, + { &hf_z3950_resultSet, + { "resultSet", "z3950.resultSet", + FT_STRING, BASE_NONE, NULL, 0, + "ResultSetId", HFILL }}, + { &hf_z3950_resultAttr, + { "resultAttr", "z3950.resultAttr_element", + FT_NONE, BASE_NONE, NULL, 0, + "ResultSetPlusAttributes", HFILL }}, + { &hf_z3950_attributes, + { "attributes", "z3950.attributes", + FT_UINT32, BASE_DEC, NULL, 0, + "AttributeList", HFILL }}, + { &hf_z3950_term, + { "term", "z3950.term", + FT_UINT32, BASE_DEC, VALS(z3950_Term_vals), 0, + NULL, HFILL }}, + { &hf_z3950_attributeList_item, + { "AttributeElement", "z3950.AttributeElement_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_general, + { "general", "z3950.general", + FT_BYTES, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_numeric, + { "numeric", "z3950.numeric", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_characterString, + { "characterString", "z3950.characterString", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_oid, + { "oid", "z3950.oid", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_dateTime, + { "dateTime", "z3950.dateTime", + FT_STRING, BASE_NONE, NULL, 0, + "GeneralizedTime", HFILL }}, + { &hf_z3950_external, + { "external", "z3950.external_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_integerAndUnit, + { "integerAndUnit", "z3950.integerAndUnit_element", + FT_NONE, BASE_NONE, NULL, 0, + "IntUnit", HFILL }}, + { &hf_z3950_null, + { "null", "z3950.null_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_and, + { "and", "z3950.and_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_or, + { "or", "z3950.or_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_and_not, + { "and-not", "z3950.and_not_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_prox, + { "prox", "z3950.prox_element", + FT_NONE, BASE_NONE, NULL, 0, + "ProximityOperator", HFILL }}, + { &hf_z3950_attributeElement_attributeType, + { "attributeType", "z3950.attributeType", + FT_INT32, BASE_DEC, NULL, 0, + "T_attributeElement_attributeType", HFILL }}, + { &hf_z3950_attributeValue, + { "attributeValue", "z3950.attributeValue", + FT_UINT32, BASE_DEC, VALS(z3950_T_attributeValue_vals), 0, + NULL, HFILL }}, + { &hf_z3950_attributeValue_numeric, + { "numeric", "z3950.numeric", + FT_INT32, BASE_DEC, NULL, 0, + "T_attributeValue_numeric", HFILL }}, + { &hf_z3950_attributeValue_complex, + { "complex", "z3950.complex_element", + FT_NONE, BASE_NONE, NULL, 0, + "T_attributeValue_complex", HFILL }}, + { &hf_z3950_attributeValue_complex_list, + { "list", "z3950.list", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_StringOrNumeric", HFILL }}, + { &hf_z3950_attributeValue_complex_list_item, + { "StringOrNumeric", "z3950.StringOrNumeric", + FT_UINT32, BASE_DEC, VALS(z3950_StringOrNumeric_vals), 0, + NULL, HFILL }}, + { &hf_z3950_semanticAction, + { "semanticAction", "z3950.semanticAction", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_semanticAction_item, + { "semanticAction item", "z3950.semanticAction_item", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_exclusion, + { "exclusion", "z3950.exclusion", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_distance, + { "distance", "z3950.distance", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_ordered, + { "ordered", "z3950.ordered", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_relationType, + { "relationType", "z3950.relationType", + FT_INT32, BASE_DEC, VALS(z3950_T_relationType_vals), 0, + NULL, HFILL }}, + { &hf_z3950_proximityUnitCode, + { "proximityUnitCode", "z3950.proximityUnitCode", + FT_UINT32, BASE_DEC, VALS(z3950_T_proximityUnitCode_vals), 0, + NULL, HFILL }}, + { &hf_z3950_known, + { "known", "z3950.known", + FT_INT32, BASE_DEC, VALS(z3950_KnownProximityUnit_vals), 0, + "KnownProximityUnit", HFILL }}, + { &hf_z3950_private, + { "private", "z3950.private", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_resultCount, + { "resultCount", "z3950.resultCount", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_numberOfRecordsReturned, + { "numberOfRecordsReturned", "z3950.numberOfRecordsReturned", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_nextResultSetPosition, + { "nextResultSetPosition", "z3950.nextResultSetPosition", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_searchStatus, + { "searchStatus", "z3950.searchStatus", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_search_resultSetStatus, + { "resultSetStatus", "z3950.resultSetStatus", + FT_INT32, BASE_DEC, VALS(z3950_T_search_resultSetStatus_vals), 0, + "T_search_resultSetStatus", HFILL }}, + { &hf_z3950_presentStatus, + { "presentStatus", "z3950.presentStatus", + FT_INT32, BASE_DEC, VALS(z3950_PresentStatus_U_vals), 0, + NULL, HFILL }}, + { &hf_z3950_records, + { "records", "z3950.records", + FT_UINT32, BASE_DEC, VALS(z3950_Records_vals), 0, + NULL, HFILL }}, + { &hf_z3950_resultSetId, + { "resultSetId", "z3950.resultSetId", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_resultSetStartPoint, + { "resultSetStartPoint", "z3950.resultSetStartPoint", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_numberOfRecordsRequested, + { "numberOfRecordsRequested", "z3950.numberOfRecordsRequested", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_additionalRanges, + { "additionalRanges", "z3950.additionalRanges", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_Range", HFILL }}, + { &hf_z3950_additionalRanges_item, + { "Range", "z3950.Range_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_recordComposition, + { "recordComposition", "z3950.recordComposition", + FT_UINT32, BASE_DEC, VALS(z3950_T_recordComposition_vals), 0, + NULL, HFILL }}, + { &hf_z3950_simple, + { "simple", "z3950.simple", + FT_UINT32, BASE_DEC, VALS(z3950_ElementSetNames_vals), 0, + "ElementSetNames", HFILL }}, + { &hf_z3950_recordComposition_complex, + { "complex", "z3950.complex_element", + FT_NONE, BASE_NONE, NULL, 0, + "CompSpec", HFILL }}, + { &hf_z3950_maxSegmentCount, + { "maxSegmentCount", "z3950.maxSegmentCount", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_maxRecordSize, + { "maxRecordSize", "z3950.maxRecordSize", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_maxSegmentSize, + { "maxSegmentSize", "z3950.maxSegmentSize", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_segmentRecords, + { "segmentRecords", "z3950.segmentRecords", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_NamePlusRecord", HFILL }}, + { &hf_z3950_segmentRecords_item, + { "NamePlusRecord", "z3950.NamePlusRecord_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_responseRecords, + { "responseRecords", "z3950.responseRecords", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_NamePlusRecord", HFILL }}, + { &hf_z3950_responseRecords_item, + { "NamePlusRecord", "z3950.NamePlusRecord_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_nonSurrogateDiagnostic, + { "nonSurrogateDiagnostic", "z3950.nonSurrogateDiagnostic_element", + FT_NONE, BASE_NONE, NULL, 0, + "DefaultDiagFormat", HFILL }}, + { &hf_z3950_multipleNonSurDiagnostics, + { "multipleNonSurDiagnostics", "z3950.multipleNonSurDiagnostics", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_DiagRec", HFILL }}, + { &hf_z3950_multipleNonSurDiagnostics_item, + { "DiagRec", "z3950.DiagRec", + FT_UINT32, BASE_DEC, VALS(z3950_DiagRec_vals), 0, + NULL, HFILL }}, + { &hf_z3950_namePlusRecord_name, + { "name", "z3950.name", + FT_STRING, BASE_NONE, NULL, 0, + "DatabaseName", HFILL }}, + { &hf_z3950_record, + { "record", "z3950.record", + FT_UINT32, BASE_DEC, VALS(z3950_T_record_vals), 0, + NULL, HFILL }}, + { &hf_z3950_retrievalRecord, + { "retrievalRecord", "z3950.retrievalRecord_element", + FT_NONE, BASE_NONE, NULL, 0, + "EXTERNAL", HFILL }}, + { &hf_z3950_surrogateDiagnostic, + { "surrogateDiagnostic", "z3950.surrogateDiagnostic", + FT_UINT32, BASE_DEC, VALS(z3950_DiagRec_vals), 0, + "DiagRec", HFILL }}, + { &hf_z3950_startingFragment, + { "startingFragment", "z3950.startingFragment", + FT_UINT32, BASE_DEC, VALS(z3950_FragmentSyntax_vals), 0, + "FragmentSyntax", HFILL }}, + { &hf_z3950_intermediateFragment, + { "intermediateFragment", "z3950.intermediateFragment", + FT_UINT32, BASE_DEC, VALS(z3950_FragmentSyntax_vals), 0, + "FragmentSyntax", HFILL }}, + { &hf_z3950_finalFragment, + { "finalFragment", "z3950.finalFragment", + FT_UINT32, BASE_DEC, VALS(z3950_FragmentSyntax_vals), 0, + "FragmentSyntax", HFILL }}, + { &hf_z3950_externallyTagged, + { "externallyTagged", "z3950.externallyTagged_element", + FT_NONE, BASE_NONE, NULL, 0, + "EXTERNAL", HFILL }}, + { &hf_z3950_notExternallyTagged, + { "notExternallyTagged", "z3950.notExternallyTagged", + FT_BYTES, BASE_NONE, NULL, 0, + "OCTET_STRING", HFILL }}, + { &hf_z3950_defaultFormat, + { "defaultFormat", "z3950.defaultFormat_element", + FT_NONE, BASE_NONE, NULL, 0, + "DefaultDiagFormat", HFILL }}, + { &hf_z3950_externallyDefined, + { "externallyDefined", "z3950.externallyDefined_element", + FT_NONE, BASE_NONE, NULL, 0, + "EXTERNAL", HFILL }}, + { &hf_z3950_diagnosticSetId, + { "diagnosticSetId", "z3950.diagnosticSetId", + FT_OID, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_condition, + { "condition", "z3950.condition", + FT_INT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_addinfo, + { "addinfo", "z3950.addinfo", + FT_UINT32, BASE_DEC, VALS(z3950_T_addinfo_vals), 0, + NULL, HFILL }}, + { &hf_z3950_v2Addinfo, + { "v2Addinfo", "z3950.v2Addinfo", + FT_STRING, BASE_NONE, NULL, 0, + "VisibleString", HFILL }}, + { &hf_z3950_v3Addinfo, + { "v3Addinfo", "z3950.v3Addinfo", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_startingPosition, + { "startingPosition", "z3950.startingPosition", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_numberOfRecords, + { "numberOfRecords", "z3950.numberOfRecords", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_genericElementSetName, + { "genericElementSetName", "z3950.genericElementSetName", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_databaseSpecific, + { "databaseSpecific", "z3950.databaseSpecific", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_databaseSpecific_item, + { "databaseSpecific item", "z3950.databaseSpecific_item_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_dbName, + { "dbName", "z3950.dbName", + FT_STRING, BASE_NONE, NULL, 0, + "DatabaseName", HFILL }}, + { &hf_z3950_esn, + { "esn", "z3950.esn", + FT_STRING, BASE_NONE, NULL, 0, + "ElementSetName", HFILL }}, + { &hf_z3950_selectAlternativeSyntax, + { "selectAlternativeSyntax", "z3950.selectAlternativeSyntax", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_compSpec_generic, + { "generic", "z3950.generic_element", + FT_NONE, BASE_NONE, NULL, 0, + "Specification", HFILL }}, + { &hf_z3950_dbSpecific, + { "dbSpecific", "z3950.dbSpecific", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_dbSpecific_item, + { "dbSpecific item", "z3950.dbSpecific_item_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_db, + { "db", "z3950.db", + FT_STRING, BASE_NONE, NULL, 0, + "DatabaseName", HFILL }}, + { &hf_z3950_spec, + { "spec", "z3950.spec_element", + FT_NONE, BASE_NONE, NULL, 0, + "Specification", HFILL }}, + { &hf_z3950_compSpec_recordSyntax, + { "recordSyntax", "z3950.recordSyntax", + FT_UINT32, BASE_DEC, NULL, 0, + "T_compSpec_recordSyntax", HFILL }}, + { &hf_z3950_compSpec_recordSyntax_item, + { "recordSyntax item", "z3950.recordSyntax_item", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_schema, + { "schema", "z3950.schema", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_specification_elementSpec, + { "elementSpec", "z3950.elementSpec", + FT_UINT32, BASE_DEC, VALS(z3950_T_specification_elementSpec_vals), 0, + "T_specification_elementSpec", HFILL }}, + { &hf_z3950_elementSetName, + { "elementSetName", "z3950.elementSetName", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_externalEspec, + { "externalEspec", "z3950.externalEspec_element", + FT_NONE, BASE_NONE, NULL, 0, + "EXTERNAL", HFILL }}, + { &hf_z3950_deleteFunction, + { "deleteFunction", "z3950.deleteFunction", + FT_INT32, BASE_DEC, VALS(z3950_T_deleteFunction_vals), 0, + NULL, HFILL }}, + { &hf_z3950_resultSetList, + { "resultSetList", "z3950.resultSetList", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_ResultSetId", HFILL }}, + { &hf_z3950_resultSetList_item, + { "ResultSetId", "z3950.ResultSetId", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_deleteOperationStatus, + { "deleteOperationStatus", "z3950.deleteOperationStatus", + FT_INT32, BASE_DEC, VALS(z3950_DeleteSetStatus_U_vals), 0, + "DeleteSetStatus", HFILL }}, + { &hf_z3950_deleteListStatuses, + { "deleteListStatuses", "z3950.deleteListStatuses", + FT_UINT32, BASE_DEC, NULL, 0, + "ListStatuses", HFILL }}, + { &hf_z3950_numberNotDeleted, + { "numberNotDeleted", "z3950.numberNotDeleted", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_bulkStatuses, + { "bulkStatuses", "z3950.bulkStatuses", + FT_UINT32, BASE_DEC, NULL, 0, + "ListStatuses", HFILL }}, + { &hf_z3950_deleteMessage, + { "deleteMessage", "z3950.deleteMessage", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_ListStatuses_item, + { "ListStatuses item", "z3950.ListStatuses_item_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_listStatuses_id, + { "id", "z3950.id", + FT_STRING, BASE_NONE, NULL, 0, + "ResultSetId", HFILL }}, + { &hf_z3950_status, + { "status", "z3950.status", + FT_INT32, BASE_DEC, VALS(z3950_DeleteSetStatus_U_vals), 0, + "DeleteSetStatus", HFILL }}, + { &hf_z3950_securityChallenge, + { "securityChallenge", "z3950.securityChallenge", + FT_UINT32, BASE_DEC, VALS(z3950_T_securityChallenge_vals), 0, + NULL, HFILL }}, + { &hf_z3950_simpleForm, + { "simpleForm", "z3950.simpleForm", + FT_BYTES, BASE_NONE, NULL, 0, + "OCTET_STRING", HFILL }}, + { &hf_z3950_securityChallengeResponse, + { "securityChallengeResponse", "z3950.securityChallengeResponse", + FT_UINT32, BASE_DEC, VALS(z3950_T_securityChallengeResponse_vals), 0, + NULL, HFILL }}, + { &hf_z3950_diagnostic, + { "diagnostic", "z3950.diagnostic", + FT_UINT32, BASE_DEC, VALS(z3950_DiagRec_vals), 0, + "DiagRec", HFILL }}, + { &hf_z3950_suspendedFlag, + { "suspendedFlag", "z3950.suspendedFlag", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_resourceReport, + { "resourceReport", "z3950.resourceReport_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_partialResultsAvailable, + { "partialResultsAvailable", "z3950.partialResultsAvailable", + FT_INT32, BASE_DEC, VALS(z3950_T_partialResultsAvailable_vals), 0, + NULL, HFILL }}, + { &hf_z3950_resourceControlRequest_responseRequired, + { "responseRequired", "z3950.responseRequired", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_triggeredRequestFlag, + { "triggeredRequestFlag", "z3950.triggeredRequestFlag", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_continueFlag, + { "continueFlag", "z3950.continueFlag", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_resultSetWanted, + { "resultSetWanted", "z3950.resultSetWanted", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_requestedAction, + { "requestedAction", "z3950.requestedAction", + FT_INT32, BASE_DEC, VALS(z3950_T_requestedAction_vals), 0, + NULL, HFILL }}, + { &hf_z3950_prefResourceReportFormat, + { "prefResourceReportFormat", "z3950.prefResourceReportFormat", + FT_OID, BASE_NONE, NULL, 0, + "ResourceReportId", HFILL }}, + { &hf_z3950_opId, + { "opId", "z3950.opId", + FT_BYTES, BASE_NONE, NULL, 0, + "ReferenceId", HFILL }}, + { &hf_z3950_resourceReportStatus, + { "resourceReportStatus", "z3950.resourceReportStatus", + FT_INT32, BASE_DEC, VALS(z3950_T_resourceReportStatus_vals), 0, + NULL, HFILL }}, + { &hf_z3950_termListAndStartPoint, + { "termListAndStartPoint", "z3950.termListAndStartPoint_element", + FT_NONE, BASE_NONE, NULL, 0, + "AttributesPlusTerm", HFILL }}, + { &hf_z3950_stepSize, + { "stepSize", "z3950.stepSize", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_numberOfTermsRequested, + { "numberOfTermsRequested", "z3950.numberOfTermsRequested", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_preferredPositionInResponse, + { "preferredPositionInResponse", "z3950.preferredPositionInResponse", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_scanStatus, + { "scanStatus", "z3950.scanStatus", + FT_INT32, BASE_DEC, VALS(z3950_T_scanStatus_vals), 0, + NULL, HFILL }}, + { &hf_z3950_numberOfEntriesReturned, + { "numberOfEntriesReturned", "z3950.numberOfEntriesReturned", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_positionOfTerm, + { "positionOfTerm", "z3950.positionOfTerm", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_scanResponse_entries, + { "entries", "z3950.entries_element", + FT_NONE, BASE_NONE, NULL, 0, + "ListEntries", HFILL }}, + { &hf_z3950_listEntries_entries, + { "entries", "z3950.entries", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_Entry", HFILL }}, + { &hf_z3950_listEntries_entries_item, + { "Entry", "z3950.Entry", + FT_UINT32, BASE_DEC, VALS(z3950_Entry_vals), 0, + NULL, HFILL }}, + { &hf_z3950_nonsurrogateDiagnostics, + { "nonsurrogateDiagnostics", "z3950.nonsurrogateDiagnostics", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_DiagRec", HFILL }}, + { &hf_z3950_nonsurrogateDiagnostics_item, + { "DiagRec", "z3950.DiagRec", + FT_UINT32, BASE_DEC, VALS(z3950_DiagRec_vals), 0, + NULL, HFILL }}, + { &hf_z3950_termInfo, + { "termInfo", "z3950.termInfo_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_displayTerm, + { "displayTerm", "z3950.displayTerm", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_suggestedAttributes, + { "suggestedAttributes", "z3950.suggestedAttributes", + FT_UINT32, BASE_DEC, NULL, 0, + "AttributeList", HFILL }}, + { &hf_z3950_alternativeTerm, + { "alternativeTerm", "z3950.alternativeTerm", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_AttributesPlusTerm", HFILL }}, + { &hf_z3950_alternativeTerm_item, + { "AttributesPlusTerm", "z3950.AttributesPlusTerm_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_globalOccurrences, + { "globalOccurrences", "z3950.globalOccurrences", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_byAttributes, + { "byAttributes", "z3950.byAttributes", + FT_UINT32, BASE_DEC, NULL, 0, + "OccurrenceByAttributes", HFILL }}, + { &hf_z3950_otherTermInfo, + { "otherTermInfo", "z3950.otherTermInfo", + FT_UINT32, BASE_DEC, NULL, 0, + "OtherInformation", HFILL }}, + { &hf_z3950_OccurrenceByAttributes_item, + { "OccurrenceByAttributes item", "z3950.OccurrenceByAttributes_item_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_occurrences, + { "occurrences", "z3950.occurrences", + FT_UINT32, BASE_DEC, VALS(z3950_T_occurrences_vals), 0, + NULL, HFILL }}, + { &hf_z3950_global, + { "global", "z3950.global", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_byDatabase, + { "byDatabase", "z3950.byDatabase", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_byDatabase_item, + { "byDatabase item", "z3950.byDatabase_item_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_num, + { "num", "z3950.num", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_otherDbInfo, + { "otherDbInfo", "z3950.otherDbInfo", + FT_UINT32, BASE_DEC, NULL, 0, + "OtherInformation", HFILL }}, + { &hf_z3950_otherOccurInfo, + { "otherOccurInfo", "z3950.otherOccurInfo", + FT_UINT32, BASE_DEC, NULL, 0, + "OtherInformation", HFILL }}, + { &hf_z3950_inputResultSetNames, + { "inputResultSetNames", "z3950.inputResultSetNames", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_InternationalString", HFILL }}, + { &hf_z3950_inputResultSetNames_item, + { "InternationalString", "z3950.InternationalString", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_sortedResultSetName, + { "sortedResultSetName", "z3950.sortedResultSetName", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_sortSequence, + { "sortSequence", "z3950.sortSequence", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_SortKeySpec", HFILL }}, + { &hf_z3950_sortSequence_item, + { "SortKeySpec", "z3950.SortKeySpec_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_sortStatus, + { "sortStatus", "z3950.sortStatus", + FT_INT32, BASE_DEC, VALS(z3950_T_sortStatus_vals), 0, + NULL, HFILL }}, + { &hf_z3950_sort_resultSetStatus, + { "resultSetStatus", "z3950.resultSetStatus", + FT_INT32, BASE_DEC, VALS(z3950_T_sort_resultSetStatus_vals), 0, + "T_sort_resultSetStatus", HFILL }}, + { &hf_z3950_diagnostics, + { "diagnostics", "z3950.diagnostics", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_DiagRec", HFILL }}, + { &hf_z3950_diagnostics_item, + { "DiagRec", "z3950.DiagRec", + FT_UINT32, BASE_DEC, VALS(z3950_DiagRec_vals), 0, + NULL, HFILL }}, + { &hf_z3950_sortElement, + { "sortElement", "z3950.sortElement", + FT_UINT32, BASE_DEC, VALS(z3950_SortElement_vals), 0, + NULL, HFILL }}, + { &hf_z3950_sortRelation, + { "sortRelation", "z3950.sortRelation", + FT_INT32, BASE_DEC, VALS(z3950_T_sortRelation_vals), 0, + NULL, HFILL }}, + { &hf_z3950_caseSensitivity, + { "caseSensitivity", "z3950.caseSensitivity", + FT_INT32, BASE_DEC, VALS(z3950_T_caseSensitivity_vals), 0, + NULL, HFILL }}, + { &hf_z3950_missingValueAction, + { "missingValueAction", "z3950.missingValueAction", + FT_UINT32, BASE_DEC, VALS(z3950_T_missingValueAction_vals), 0, + NULL, HFILL }}, + { &hf_z3950_abort, + { "abort", "z3950.abort_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_missingValueData, + { "missingValueData", "z3950.missingValueData", + FT_BYTES, BASE_NONE, NULL, 0, + "OCTET_STRING", HFILL }}, + { &hf_z3950_sortElement_generic, + { "generic", "z3950.generic", + FT_UINT32, BASE_DEC, VALS(z3950_SortKey_vals), 0, + "SortKey", HFILL }}, + { &hf_z3950_datbaseSpecific, + { "datbaseSpecific", "z3950.datbaseSpecific", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_datbaseSpecific_item, + { "datbaseSpecific item", "z3950.datbaseSpecific_item_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_databaseName, + { "databaseName", "z3950.databaseName", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_dbSort, + { "dbSort", "z3950.dbSort", + FT_UINT32, BASE_DEC, VALS(z3950_SortKey_vals), 0, + "SortKey", HFILL }}, + { &hf_z3950_sortfield, + { "sortfield", "z3950.sortfield", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_sortKey_elementSpec, + { "elementSpec", "z3950.elementSpec_element", + FT_NONE, BASE_NONE, NULL, 0, + "Specification", HFILL }}, + { &hf_z3950_sortAttributes, + { "sortAttributes", "z3950.sortAttributes_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_sortAttributes_id, + { "id", "z3950.id", + FT_OID, BASE_NONE, NULL, 0, + "AttributeSetId", HFILL }}, + { &hf_z3950_sortAttributes_list, + { "list", "z3950.list", + FT_UINT32, BASE_DEC, NULL, 0, + "AttributeList", HFILL }}, + { &hf_z3950_function, + { "function", "z3950.function", + FT_INT32, BASE_DEC, VALS(z3950_T_function_vals), 0, + NULL, HFILL }}, + { &hf_z3950_packageType, + { "packageType", "z3950.packageType", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_packageName, + { "packageName", "z3950.packageName", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_retentionTime, + { "retentionTime", "z3950.retentionTime_element", + FT_NONE, BASE_NONE, NULL, 0, + "IntUnit", HFILL }}, + { &hf_z3950_permissions, + { "permissions", "z3950.permissions", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_extendedServicesRequest_description, + { "description", "z3950.description", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_taskSpecificParameters, + { "taskSpecificParameters", "z3950.taskSpecificParameters_element", + FT_NONE, BASE_NONE, NULL, 0, + "EXTERNAL", HFILL }}, + { &hf_z3950_waitAction, + { "waitAction", "z3950.waitAction", + FT_INT32, BASE_DEC, VALS(z3950_T_waitAction_vals), 0, + NULL, HFILL }}, + { &hf_z3950_elements, + { "elements", "z3950.elements", + FT_STRING, BASE_NONE, NULL, 0, + "ElementSetName", HFILL }}, + { &hf_z3950_operationStatus, + { "operationStatus", "z3950.operationStatus", + FT_INT32, BASE_DEC, VALS(z3950_T_operationStatus_vals), 0, + NULL, HFILL }}, + { &hf_z3950_taskPackage, + { "taskPackage", "z3950.taskPackage_element", + FT_NONE, BASE_NONE, NULL, 0, + "EXTERNAL", HFILL }}, + { &hf_z3950_Permissions_item, + { "Permissions item", "z3950.Permissions_item_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_allowableFunctions, + { "allowableFunctions", "z3950.allowableFunctions", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_allowableFunctions_item, + { "allowableFunctions item", "z3950.allowableFunctions_item", + FT_INT32, BASE_DEC, VALS(z3950_T_allowableFunctions_item_vals), 0, + NULL, HFILL }}, + { &hf_z3950_closeReason, + { "closeReason", "z3950.closeReason", + FT_INT32, BASE_DEC, VALS(z3950_CloseReason_U_vals), 0, + NULL, HFILL }}, + { &hf_z3950_diagnosticInformation, + { "diagnosticInformation", "z3950.diagnosticInformation", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_resourceReportFormat, + { "resourceReportFormat", "z3950.resourceReportFormat", + FT_OID, BASE_NONE, NULL, 0, + "ResourceReportId", HFILL }}, + { &hf_z3950_otherInformation_item, + { "_untag item", "z3950._untag_item_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_category, + { "category", "z3950.category_element", + FT_NONE, BASE_NONE, NULL, 0, + "InfoCategory", HFILL }}, + { &hf_z3950_information, + { "information", "z3950.information", + FT_UINT32, BASE_DEC, VALS(z3950_T_information_vals), 0, + NULL, HFILL }}, + { &hf_z3950_characterInfo, + { "characterInfo", "z3950.characterInfo", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_binaryInfo, + { "binaryInfo", "z3950.binaryInfo", + FT_BYTES, BASE_NONE, NULL, 0, + "OCTET_STRING", HFILL }}, + { &hf_z3950_externallyDefinedInfo, + { "externallyDefinedInfo", "z3950.externallyDefinedInfo_element", + FT_NONE, BASE_NONE, NULL, 0, + "EXTERNAL", HFILL }}, + { &hf_z3950_categoryTypeId, + { "categoryTypeId", "z3950.categoryTypeId", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_categoryValue, + { "categoryValue", "z3950.categoryValue", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_value, + { "value", "z3950.value", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_unitUsed, + { "unitUsed", "z3950.unitUsed_element", + FT_NONE, BASE_NONE, NULL, 0, + "Unit", HFILL }}, + { &hf_z3950_unitSystem, + { "unitSystem", "z3950.unitSystem", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_unitType, + { "unitType", "z3950.unitType", + FT_UINT32, BASE_DEC, VALS(z3950_StringOrNumeric_vals), 0, + "StringOrNumeric", HFILL }}, + { &hf_z3950_unit, + { "unit", "z3950.unit", + FT_UINT32, BASE_DEC, VALS(z3950_StringOrNumeric_vals), 0, + "StringOrNumeric", HFILL }}, + { &hf_z3950_scaleFactor, + { "scaleFactor", "z3950.scaleFactor", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_string, + { "string", "z3950.string", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_motd, + { "motd", "z3950.motd", + FT_STRING, BASE_NONE, NULL, 0, + "VisibleString", HFILL }}, + { &hf_z3950_dblist, + { "dblist", "z3950.dblist", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_DBName", HFILL }}, + { &hf_z3950_dblist_item, + { "DBName", "z3950.DBName", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_failReason, + { "failReason", "z3950.failReason", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_oCLC_UserInformation_text, + { "text", "z3950.text", + FT_STRING, BASE_NONE, NULL, 0, + "VisibleString", HFILL }}, + { &hf_z3950_bibliographicRecord, + { "bibliographicRecord", "z3950.bibliographicRecord_element", + FT_NONE, BASE_NONE, NULL, 0, + "EXTERNAL", HFILL }}, + { &hf_z3950_holdingsData, + { "holdingsData", "z3950.holdingsData", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_HoldingsRecord", HFILL }}, + { &hf_z3950_holdingsData_item, + { "HoldingsRecord", "z3950.HoldingsRecord", + FT_UINT32, BASE_DEC, VALS(z3950_HoldingsRecord_vals), 0, + NULL, HFILL }}, + { &hf_z3950_marcHoldingsRecord, + { "marcHoldingsRecord", "z3950.marcHoldingsRecord_element", + FT_NONE, BASE_NONE, NULL, 0, + "EXTERNAL", HFILL }}, + { &hf_z3950_holdingsAndCirc, + { "holdingsAndCirc", "z3950.holdingsAndCirc_element", + FT_NONE, BASE_NONE, NULL, 0, + "HoldingsAndCircData", HFILL }}, + { &hf_z3950_typeOfRecord, + { "typeOfRecord", "z3950.typeOfRecord", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_encodingLevel, + { "encodingLevel", "z3950.encodingLevel", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_format, + { "format", "z3950.format", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_receiptAcqStatus, + { "receiptAcqStatus", "z3950.receiptAcqStatus", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_generalRetention, + { "generalRetention", "z3950.generalRetention", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_completeness, + { "completeness", "z3950.completeness", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_dateOfReport, + { "dateOfReport", "z3950.dateOfReport", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_nucCode, + { "nucCode", "z3950.nucCode", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_localLocation, + { "localLocation", "z3950.localLocation", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_shelvingLocation, + { "shelvingLocation", "z3950.shelvingLocation", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_callNumber, + { "callNumber", "z3950.callNumber", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_shelvingData, + { "shelvingData", "z3950.shelvingData", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_copyNumber, + { "copyNumber", "z3950.copyNumber", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_publicNote, + { "publicNote", "z3950.publicNote", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_reproductionNote, + { "reproductionNote", "z3950.reproductionNote", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_termsUseRepro, + { "termsUseRepro", "z3950.termsUseRepro", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_enumAndChron, + { "enumAndChron", "z3950.enumAndChron", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_volumes, + { "volumes", "z3950.volumes", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_Volume", HFILL }}, + { &hf_z3950_volumes_item, + { "Volume", "z3950.Volume_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_circulationData, + { "circulationData", "z3950.circulationData", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_CircRecord", HFILL }}, + { &hf_z3950_circulationData_item, + { "CircRecord", "z3950.CircRecord_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_enumeration, + { "enumeration", "z3950.enumeration", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_chronology, + { "chronology", "z3950.chronology", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_availableNow, + { "availableNow", "z3950.availableNow", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_availablityDate, + { "availablityDate", "z3950.availablityDate", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_availableThru, + { "availableThru", "z3950.availableThru", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_circRecord_restrictions, + { "restrictions", "z3950.restrictions", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_itemId, + { "itemId", "z3950.itemId", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_renewable, + { "renewable", "z3950.renewable", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_onHold, + { "onHold", "z3950.onHold", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_midspine, + { "midspine", "z3950.midspine", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_temporaryLocation, + { "temporaryLocation", "z3950.temporaryLocation", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_DiagnosticFormat_item, + { "DiagnosticFormat item", "z3950.DiagnosticFormat_item_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_diagnosticFormat_item_diagnostic, + { "diagnostic", "z3950.diagnostic", + FT_UINT32, BASE_DEC, VALS(z3950_T_diagnosticFormat_item_diagnostic_vals), 0, + "T_diagnosticFormat_item_diagnostic", HFILL }}, + { &hf_z3950_defaultDiagRec, + { "defaultDiagRec", "z3950.defaultDiagRec_element", + FT_NONE, BASE_NONE, NULL, 0, + "DefaultDiagFormat", HFILL }}, + { &hf_z3950_explicitDiagnostic, + { "explicitDiagnostic", "z3950.explicitDiagnostic", + FT_UINT32, BASE_DEC, VALS(z3950_DiagFormat_vals), 0, + "DiagFormat", HFILL }}, + { &hf_z3950_message, + { "message", "z3950.message", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_tooMany, + { "tooMany", "z3950.tooMany_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_tooManyWhat, + { "tooManyWhat", "z3950.tooManyWhat", + FT_INT32, BASE_DEC, VALS(z3950_T_tooManyWhat_vals), 0, + NULL, HFILL }}, + { &hf_z3950_max, + { "max", "z3950.max", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_badSpec, + { "badSpec", "z3950.badSpec_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_goodOnes, + { "goodOnes", "z3950.goodOnes", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_Specification", HFILL }}, + { &hf_z3950_goodOnes_item, + { "Specification", "z3950.Specification_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_dbUnavail, + { "dbUnavail", "z3950.dbUnavail_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_why, + { "why", "z3950.why_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_reasonCode, + { "reasonCode", "z3950.reasonCode", + FT_INT32, BASE_DEC, VALS(z3950_T_reasonCode_vals), 0, + NULL, HFILL }}, + { &hf_z3950_unSupOp, + { "unSupOp", "z3950.unSupOp", + FT_INT32, BASE_DEC, VALS(z3950_T_unSupOp_vals), 0, + NULL, HFILL }}, + { &hf_z3950_attribute, + { "attribute", "z3950.attribute_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_id, + { "id", "z3950.id", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_type, + { "type", "z3950.type", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_attCombo, + { "attCombo", "z3950.attCombo_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_unsupportedCombination, + { "unsupportedCombination", "z3950.unsupportedCombination", + FT_UINT32, BASE_DEC, NULL, 0, + "AttributeList", HFILL }}, + { &hf_z3950_recommendedAlternatives, + { "recommendedAlternatives", "z3950.recommendedAlternatives", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_AttributeList", HFILL }}, + { &hf_z3950_recommendedAlternatives_item, + { "AttributeList", "z3950.AttributeList", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_diagFormat_term, + { "term", "z3950.term_element", + FT_NONE, BASE_NONE, NULL, 0, + "T_diagFormat_term", HFILL }}, + { &hf_z3950_problem, + { "problem", "z3950.problem", + FT_INT32, BASE_DEC, VALS(z3950_T_problem_vals), 0, + NULL, HFILL }}, + { &hf_z3950_diagFormat_proximity, + { "proximity", "z3950.proximity", + FT_UINT32, BASE_DEC, VALS(z3950_T_diagFormat_proximity_vals), 0, + "T_diagFormat_proximity", HFILL }}, + { &hf_z3950_resultSets, + { "resultSets", "z3950.resultSets_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_badSet, + { "badSet", "z3950.badSet", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_relation, + { "relation", "z3950.relation", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_diagFormat_proximity_unit, + { "unit", "z3950.unit", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_diagFormat_proximity_ordered, + { "ordered", "z3950.ordered_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_diagFormat_proximity_exclusion, + { "exclusion", "z3950.exclusion_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_scan, + { "scan", "z3950.scan", + FT_UINT32, BASE_DEC, VALS(z3950_T_scan_vals), 0, + NULL, HFILL }}, + { &hf_z3950_nonZeroStepSize, + { "nonZeroStepSize", "z3950.nonZeroStepSize_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_specifiedStepSize, + { "specifiedStepSize", "z3950.specifiedStepSize_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_termList1, + { "termList1", "z3950.termList1_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_termList2, + { "termList2", "z3950.termList2", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_AttributeList", HFILL }}, + { &hf_z3950_termList2_item, + { "AttributeList", "z3950.AttributeList", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_posInResponse, + { "posInResponse", "z3950.posInResponse", + FT_INT32, BASE_DEC, VALS(z3950_T_posInResponse_vals), 0, + NULL, HFILL }}, + { &hf_z3950_resources, + { "resources", "z3950.resources_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_endOfList, + { "endOfList", "z3950.endOfList_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_sort, + { "sort", "z3950.sort", + FT_UINT32, BASE_DEC, VALS(z3950_T_sort_vals), 0, + NULL, HFILL }}, + { &hf_z3950_sequence, + { "sequence", "z3950.sequence_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_noRsName, + { "noRsName", "z3950.noRsName_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_diagFormat_sort_tooMany, + { "tooMany", "z3950.tooMany", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_incompatible, + { "incompatible", "z3950.incompatible_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_generic, + { "generic", "z3950.generic_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_diagFormat_sort_dbSpecific, + { "dbSpecific", "z3950.dbSpecific_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_key, + { "key", "z3950.key", + FT_INT32, BASE_DEC, VALS(z3950_T_key_vals), 0, + NULL, HFILL }}, + { &hf_z3950_action, + { "action", "z3950.action_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_illegal, + { "illegal", "z3950.illegal", + FT_INT32, BASE_DEC, VALS(z3950_T_illegal_vals), 0, + NULL, HFILL }}, + { &hf_z3950_inputTooLarge, + { "inputTooLarge", "z3950.inputTooLarge", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_InternationalString", HFILL }}, + { &hf_z3950_inputTooLarge_item, + { "InternationalString", "z3950.InternationalString", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_aggregateTooLarge, + { "aggregateTooLarge", "z3950.aggregateTooLarge_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_segmentation, + { "segmentation", "z3950.segmentation", + FT_UINT32, BASE_DEC, VALS(z3950_T_segmentation_vals), 0, + NULL, HFILL }}, + { &hf_z3950_segmentCount, + { "segmentCount", "z3950.segmentCount_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_segmentSize, + { "segmentSize", "z3950.segmentSize", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_extServices, + { "extServices", "z3950.extServices", + FT_UINT32, BASE_DEC, VALS(z3950_T_extServices_vals), 0, + NULL, HFILL }}, + { &hf_z3950_req, + { "req", "z3950.req", + FT_INT32, BASE_DEC, VALS(z3950_T_req_vals), 0, + NULL, HFILL }}, + { &hf_z3950_permission, + { "permission", "z3950.permission", + FT_INT32, BASE_DEC, VALS(z3950_T_permission_vals), 0, + NULL, HFILL }}, + { &hf_z3950_immediate, + { "immediate", "z3950.immediate", + FT_INT32, BASE_DEC, VALS(z3950_T_immediate_vals), 0, + NULL, HFILL }}, + { &hf_z3950_accessCtrl, + { "accessCtrl", "z3950.accessCtrl", + FT_UINT32, BASE_DEC, VALS(z3950_T_accessCtrl_vals), 0, + NULL, HFILL }}, + { &hf_z3950_noUser, + { "noUser", "z3950.noUser_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_refused, + { "refused", "z3950.refused_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_diagFormat_accessCtrl_simple, + { "simple", "z3950.simple_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_diagFormat_accessCtrl_oid, + { "oid", "z3950.oid", + FT_UINT32, BASE_DEC, NULL, 0, + "T_diagFormat_accessCtrl_oid", HFILL }}, + { &hf_z3950_diagFormat_accessCtrl_oid_item, + { "oid item", "z3950.oid_item", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_alternative, + { "alternative", "z3950.alternative", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_alternative_item, + { "alternative item", "z3950.alternative_item", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_pwdInv, + { "pwdInv", "z3950.pwdInv_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_pwdExp, + { "pwdExp", "z3950.pwdExp_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_diagFormat_recordSyntax, + { "recordSyntax", "z3950.recordSyntax_element", + FT_NONE, BASE_NONE, NULL, 0, + "T_diagFormat_recordSyntax", HFILL }}, + { &hf_z3950_unsupportedSyntax, + { "unsupportedSyntax", "z3950.unsupportedSyntax", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_suggestedAlternatives, + { "suggestedAlternatives", "z3950.suggestedAlternatives", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_suggestedAlternatives_item, + { "suggestedAlternatives item", "z3950.suggestedAlternatives_item", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_targetInfo, + { "targetInfo", "z3950.targetInfo_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_databaseInfo, + { "databaseInfo", "z3950.databaseInfo_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_schemaInfo, + { "schemaInfo", "z3950.schemaInfo_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_tagSetInfo, + { "tagSetInfo", "z3950.tagSetInfo_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_recordSyntaxInfo, + { "recordSyntaxInfo", "z3950.recordSyntaxInfo_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_attributeSetInfo, + { "attributeSetInfo", "z3950.attributeSetInfo_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_termListInfo, + { "termListInfo", "z3950.termListInfo_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_extendedServicesInfo, + { "extendedServicesInfo", "z3950.extendedServicesInfo_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_attributeDetails, + { "attributeDetails", "z3950.attributeDetails_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_termListDetails, + { "termListDetails", "z3950.termListDetails_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_elementSetDetails, + { "elementSetDetails", "z3950.elementSetDetails_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_retrievalRecordDetails, + { "retrievalRecordDetails", "z3950.retrievalRecordDetails_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_sortDetails, + { "sortDetails", "z3950.sortDetails_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_processing, + { "processing", "z3950.processing_element", + FT_NONE, BASE_NONE, NULL, 0, + "ProcessingInformation", HFILL }}, + { &hf_z3950_variants, + { "variants", "z3950.variants_element", + FT_NONE, BASE_NONE, NULL, 0, + "VariantSetInfo", HFILL }}, + { &hf_z3950_units, + { "units", "z3950.units_element", + FT_NONE, BASE_NONE, NULL, 0, + "UnitInfo", HFILL }}, + { &hf_z3950_categoryList, + { "categoryList", "z3950.categoryList_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_commonInfo, + { "commonInfo", "z3950.commonInfo_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_name, + { "name", "z3950.name", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_recent_news, + { "recent-news", "z3950.recent_news", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_icon, + { "icon", "z3950.icon", + FT_UINT32, BASE_DEC, NULL, 0, + "IconObject", HFILL }}, + { &hf_z3950_namedResultSets, + { "namedResultSets", "z3950.namedResultSets", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_multipleDBsearch, + { "multipleDBsearch", "z3950.multipleDBsearch", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_maxResultSets, + { "maxResultSets", "z3950.maxResultSets", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_maxResultSize, + { "maxResultSize", "z3950.maxResultSize", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_maxTerms, + { "maxTerms", "z3950.maxTerms", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_timeoutInterval, + { "timeoutInterval", "z3950.timeoutInterval_element", + FT_NONE, BASE_NONE, NULL, 0, + "IntUnit", HFILL }}, + { &hf_z3950_welcomeMessage, + { "welcomeMessage", "z3950.welcomeMessage", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_contactInfo, + { "contactInfo", "z3950.contactInfo_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_description, + { "description", "z3950.description", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_nicknames, + { "nicknames", "z3950.nicknames", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_InternationalString", HFILL }}, + { &hf_z3950_nicknames_item, + { "InternationalString", "z3950.InternationalString", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_usage_restrictions, + { "usage-restrictions", "z3950.usage_restrictions", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_paymentAddr, + { "paymentAddr", "z3950.paymentAddr", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_hours, + { "hours", "z3950.hours", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_dbCombinations, + { "dbCombinations", "z3950.dbCombinations", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_DatabaseList", HFILL }}, + { &hf_z3950_dbCombinations_item, + { "DatabaseList", "z3950.DatabaseList", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_addresses, + { "addresses", "z3950.addresses", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_NetworkAddress", HFILL }}, + { &hf_z3950_addresses_item, + { "NetworkAddress", "z3950.NetworkAddress", + FT_UINT32, BASE_DEC, VALS(z3950_NetworkAddress_vals), 0, + NULL, HFILL }}, + { &hf_z3950_languages, + { "languages", "z3950.languages", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_InternationalString", HFILL }}, + { &hf_z3950_languages_item, + { "InternationalString", "z3950.InternationalString", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_commonAccessInfo, + { "commonAccessInfo", "z3950.commonAccessInfo_element", + FT_NONE, BASE_NONE, NULL, 0, + "AccessInfo", HFILL }}, + { &hf_z3950_databaseInfo_name, + { "name", "z3950.name", + FT_STRING, BASE_NONE, NULL, 0, + "DatabaseName", HFILL }}, + { &hf_z3950_explainDatabase, + { "explainDatabase", "z3950.explainDatabase_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_databaseInfo_nicknames, + { "nicknames", "z3950.nicknames", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_DatabaseName", HFILL }}, + { &hf_z3950_databaseInfo_nicknames_item, + { "DatabaseName", "z3950.DatabaseName", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_user_fee, + { "user-fee", "z3950.user_fee", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_available, + { "available", "z3950.available", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_titleString, + { "titleString", "z3950.titleString", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_keywords, + { "keywords", "z3950.keywords", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_HumanString", HFILL }}, + { &hf_z3950_keywords_item, + { "HumanString", "z3950.HumanString", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_associatedDbs, + { "associatedDbs", "z3950.associatedDbs", + FT_UINT32, BASE_DEC, NULL, 0, + "DatabaseList", HFILL }}, + { &hf_z3950_subDbs, + { "subDbs", "z3950.subDbs", + FT_UINT32, BASE_DEC, NULL, 0, + "DatabaseList", HFILL }}, + { &hf_z3950_disclaimers, + { "disclaimers", "z3950.disclaimers", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_news, + { "news", "z3950.news", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_recordCount, + { "recordCount", "z3950.recordCount", + FT_UINT32, BASE_DEC, VALS(z3950_T_recordCount_vals), 0, + NULL, HFILL }}, + { &hf_z3950_actualNumber, + { "actualNumber", "z3950.actualNumber", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_approxNumber, + { "approxNumber", "z3950.approxNumber", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_defaultOrder, + { "defaultOrder", "z3950.defaultOrder", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_avRecordSize, + { "avRecordSize", "z3950.avRecordSize", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_bestTime, + { "bestTime", "z3950.bestTime", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_lastUpdate, + { "lastUpdate", "z3950.lastUpdate", + FT_STRING, BASE_NONE, NULL, 0, + "GeneralizedTime", HFILL }}, + { &hf_z3950_updateInterval, + { "updateInterval", "z3950.updateInterval_element", + FT_NONE, BASE_NONE, NULL, 0, + "IntUnit", HFILL }}, + { &hf_z3950_coverage, + { "coverage", "z3950.coverage", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_proprietary, + { "proprietary", "z3950.proprietary", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_copyrightText, + { "copyrightText", "z3950.copyrightText", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_copyrightNotice, + { "copyrightNotice", "z3950.copyrightNotice", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_producerContactInfo, + { "producerContactInfo", "z3950.producerContactInfo_element", + FT_NONE, BASE_NONE, NULL, 0, + "ContactInfo", HFILL }}, + { &hf_z3950_supplierContactInfo, + { "supplierContactInfo", "z3950.supplierContactInfo_element", + FT_NONE, BASE_NONE, NULL, 0, + "ContactInfo", HFILL }}, + { &hf_z3950_submissionContactInfo, + { "submissionContactInfo", "z3950.submissionContactInfo_element", + FT_NONE, BASE_NONE, NULL, 0, + "ContactInfo", HFILL }}, + { &hf_z3950_accessInfo, + { "accessInfo", "z3950.accessInfo_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_tagTypeMapping, + { "tagTypeMapping", "z3950.tagTypeMapping", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_tagTypeMapping_item, + { "tagTypeMapping item", "z3950.tagTypeMapping_item_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_tagType, + { "tagType", "z3950.tagType", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_tagSet, + { "tagSet", "z3950.tagSet", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_defaultTagType, + { "defaultTagType", "z3950.defaultTagType_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_recordStructure, + { "recordStructure", "z3950.recordStructure", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_ElementInfo", HFILL }}, + { &hf_z3950_recordStructure_item, + { "ElementInfo", "z3950.ElementInfo_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_elementName, + { "elementName", "z3950.elementName", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_elementTagPath, + { "elementTagPath", "z3950.elementTagPath", + FT_UINT32, BASE_DEC, NULL, 0, + "Path", HFILL }}, + { &hf_z3950_elementInfo_dataType, + { "dataType", "z3950.dataType", + FT_UINT32, BASE_DEC, VALS(z3950_ElementDataType_vals), 0, + "ElementDataType", HFILL }}, + { &hf_z3950_required, + { "required", "z3950.required", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_repeatable, + { "repeatable", "z3950.repeatable", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_Path_item, + { "Path item", "z3950.Path_item_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_tagValue, + { "tagValue", "z3950.tagValue", + FT_UINT32, BASE_DEC, VALS(z3950_StringOrNumeric_vals), 0, + "StringOrNumeric", HFILL }}, + { &hf_z3950_primitive, + { "primitive", "z3950.primitive", + FT_INT32, BASE_DEC, VALS(z3950_PrimitiveDataType_vals), 0, + "PrimitiveDataType", HFILL }}, + { &hf_z3950_structured, + { "structured", "z3950.structured", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_ElementInfo", HFILL }}, + { &hf_z3950_structured_item, + { "ElementInfo", "z3950.ElementInfo_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_tagSetInfo_elements, + { "elements", "z3950.elements", + FT_UINT32, BASE_DEC, NULL, 0, + "T_tagSetInfo_elements", HFILL }}, + { &hf_z3950_tagSetInfo_elements_item, + { "elements item", "z3950.elements_item_element", + FT_NONE, BASE_NONE, NULL, 0, + "T_tagSetInfo_elements_item", HFILL }}, + { &hf_z3950_elementname, + { "elementname", "z3950.elementname", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_elementTag, + { "elementTag", "z3950.elementTag", + FT_UINT32, BASE_DEC, VALS(z3950_StringOrNumeric_vals), 0, + "StringOrNumeric", HFILL }}, + { &hf_z3950_dataType, + { "dataType", "z3950.dataType", + FT_INT32, BASE_DEC, VALS(z3950_PrimitiveDataType_vals), 0, + "PrimitiveDataType", HFILL }}, + { &hf_z3950_otherTagInfo, + { "otherTagInfo", "z3950.otherTagInfo", + FT_UINT32, BASE_DEC, NULL, 0, + "OtherInformation", HFILL }}, + { &hf_z3950_recordSyntax, + { "recordSyntax", "z3950.recordSyntax", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_transferSyntaxes, + { "transferSyntaxes", "z3950.transferSyntaxes", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_transferSyntaxes_item, + { "transferSyntaxes item", "z3950.transferSyntaxes_item", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_asn1Module, + { "asn1Module", "z3950.asn1Module", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_abstractStructure, + { "abstractStructure", "z3950.abstractStructure", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_ElementInfo", HFILL }}, + { &hf_z3950_abstractStructure_item, + { "ElementInfo", "z3950.ElementInfo_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_attributeSetInfo_attributes, + { "attributes", "z3950.attributes", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_AttributeType", HFILL }}, + { &hf_z3950_attributeSetInfo_attributes_item, + { "AttributeType", "z3950.AttributeType_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_attributeType, + { "attributeType", "z3950.attributeType", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_attributeValues, + { "attributeValues", "z3950.attributeValues", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_AttributeDescription", HFILL }}, + { &hf_z3950_attributeValues_item, + { "AttributeDescription", "z3950.AttributeDescription_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_attributeDescription_attributeValue, + { "attributeValue", "z3950.attributeValue", + FT_UINT32, BASE_DEC, VALS(z3950_StringOrNumeric_vals), 0, + "StringOrNumeric", HFILL }}, + { &hf_z3950_equivalentAttributes, + { "equivalentAttributes", "z3950.equivalentAttributes", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_StringOrNumeric", HFILL }}, + { &hf_z3950_equivalentAttributes_item, + { "StringOrNumeric", "z3950.StringOrNumeric", + FT_UINT32, BASE_DEC, VALS(z3950_StringOrNumeric_vals), 0, + NULL, HFILL }}, + { &hf_z3950_termLists, + { "termLists", "z3950.termLists", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_termLists_item, + { "termLists item", "z3950.termLists_item_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_title, + { "title", "z3950.title", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_searchCost, + { "searchCost", "z3950.searchCost", + FT_INT32, BASE_DEC, VALS(z3950_T_searchCost_vals), 0, + NULL, HFILL }}, + { &hf_z3950_scanable, + { "scanable", "z3950.scanable", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_broader, + { "broader", "z3950.broader", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_InternationalString", HFILL }}, + { &hf_z3950_broader_item, + { "InternationalString", "z3950.InternationalString", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_narrower, + { "narrower", "z3950.narrower", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_InternationalString", HFILL }}, + { &hf_z3950_narrower_item, + { "InternationalString", "z3950.InternationalString", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_extendedServicesInfo_type, + { "type", "z3950.type", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_privateType, + { "privateType", "z3950.privateType", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_restrictionsApply, + { "restrictionsApply", "z3950.restrictionsApply", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_feeApply, + { "feeApply", "z3950.feeApply", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_retentionSupported, + { "retentionSupported", "z3950.retentionSupported", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_extendedServicesInfo_waitAction, + { "waitAction", "z3950.waitAction", + FT_INT32, BASE_DEC, VALS(z3950_T_extendedServicesInfo_waitAction_vals), 0, + "T_extendedServicesInfo_waitAction", HFILL }}, + { &hf_z3950_specificExplain, + { "specificExplain", "z3950.specificExplain_element", + FT_NONE, BASE_NONE, NULL, 0, + "EXTERNAL", HFILL }}, + { &hf_z3950_esASN, + { "esASN", "z3950.esASN", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_attributesBySet, + { "attributesBySet", "z3950.attributesBySet", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_AttributeSetDetails", HFILL }}, + { &hf_z3950_attributesBySet_item, + { "AttributeSetDetails", "z3950.AttributeSetDetails_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_attributeCombinations, + { "attributeCombinations", "z3950.attributeCombinations_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_attributesByType, + { "attributesByType", "z3950.attributesByType", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_AttributeTypeDetails", HFILL }}, + { &hf_z3950_attributesByType_item, + { "AttributeTypeDetails", "z3950.AttributeTypeDetails_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_defaultIfOmitted, + { "defaultIfOmitted", "z3950.defaultIfOmitted_element", + FT_NONE, BASE_NONE, NULL, 0, + "OmittedAttributeInterpretation", HFILL }}, + { &hf_z3950_attributeTypeDetails_attributeValues, + { "attributeValues", "z3950.attributeValues", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_AttributeValue", HFILL }}, + { &hf_z3950_attributeTypeDetails_attributeValues_item, + { "AttributeValue", "z3950.AttributeValue_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_defaultValue, + { "defaultValue", "z3950.defaultValue", + FT_UINT32, BASE_DEC, VALS(z3950_StringOrNumeric_vals), 0, + "StringOrNumeric", HFILL }}, + { &hf_z3950_defaultDescription, + { "defaultDescription", "z3950.defaultDescription", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_attributeValue_value, + { "value", "z3950.value", + FT_UINT32, BASE_DEC, VALS(z3950_StringOrNumeric_vals), 0, + "StringOrNumeric", HFILL }}, + { &hf_z3950_subAttributes, + { "subAttributes", "z3950.subAttributes", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_StringOrNumeric", HFILL }}, + { &hf_z3950_subAttributes_item, + { "StringOrNumeric", "z3950.StringOrNumeric", + FT_UINT32, BASE_DEC, VALS(z3950_StringOrNumeric_vals), 0, + NULL, HFILL }}, + { &hf_z3950_superAttributes, + { "superAttributes", "z3950.superAttributes", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_StringOrNumeric", HFILL }}, + { &hf_z3950_superAttributes_item, + { "StringOrNumeric", "z3950.StringOrNumeric", + FT_UINT32, BASE_DEC, VALS(z3950_StringOrNumeric_vals), 0, + NULL, HFILL }}, + { &hf_z3950_partialSupport, + { "partialSupport", "z3950.partialSupport_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_termListName, + { "termListName", "z3950.termListName", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_termListDetails_attributes, + { "attributes", "z3950.attributes_element", + FT_NONE, BASE_NONE, NULL, 0, + "AttributeCombinations", HFILL }}, + { &hf_z3950_scanInfo, + { "scanInfo", "z3950.scanInfo_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_maxStepSize, + { "maxStepSize", "z3950.maxStepSize", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_collatingSequence, + { "collatingSequence", "z3950.collatingSequence", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_increasing, + { "increasing", "z3950.increasing", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_estNumberTerms, + { "estNumberTerms", "z3950.estNumberTerms", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_sampleTerms, + { "sampleTerms", "z3950.sampleTerms", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_Term", HFILL }}, + { &hf_z3950_sampleTerms_item, + { "Term", "z3950.Term", + FT_UINT32, BASE_DEC, VALS(z3950_Term_vals), 0, + NULL, HFILL }}, + { &hf_z3950_elementSetDetails_elementSetName, + { "elementSetName", "z3950.elementSetName", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_detailsPerElement, + { "detailsPerElement", "z3950.detailsPerElement", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_PerElementDetails", HFILL }}, + { &hf_z3950_detailsPerElement_item, + { "PerElementDetails", "z3950.PerElementDetails_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_recordTag, + { "recordTag", "z3950.recordTag_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_schemaTags, + { "schemaTags", "z3950.schemaTags", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_Path", HFILL }}, + { &hf_z3950_schemaTags_item, + { "Path", "z3950.Path", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_maxSize, + { "maxSize", "z3950.maxSize", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_minSize, + { "minSize", "z3950.minSize", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_avgSize, + { "avgSize", "z3950.avgSize", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_fixedSize, + { "fixedSize", "z3950.fixedSize", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_contents, + { "contents", "z3950.contents", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_billingInfo, + { "billingInfo", "z3950.billingInfo", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_restrictions, + { "restrictions", "z3950.restrictions", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_alternateNames, + { "alternateNames", "z3950.alternateNames", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_InternationalString", HFILL }}, + { &hf_z3950_alternateNames_item, + { "InternationalString", "z3950.InternationalString", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_genericNames, + { "genericNames", "z3950.genericNames", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_InternationalString", HFILL }}, + { &hf_z3950_genericNames_item, + { "InternationalString", "z3950.InternationalString", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_searchAccess, + { "searchAccess", "z3950.searchAccess_element", + FT_NONE, BASE_NONE, NULL, 0, + "AttributeCombinations", HFILL }}, + { &hf_z3950_qualifier, + { "qualifier", "z3950.qualifier", + FT_UINT32, BASE_DEC, VALS(z3950_StringOrNumeric_vals), 0, + "StringOrNumeric", HFILL }}, + { &hf_z3950_sortKeys, + { "sortKeys", "z3950.sortKeys", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_SortKeyDetails", HFILL }}, + { &hf_z3950_sortKeys_item, + { "SortKeyDetails", "z3950.SortKeyDetails_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_elementSpecifications, + { "elementSpecifications", "z3950.elementSpecifications", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_Specification", HFILL }}, + { &hf_z3950_elementSpecifications_item, + { "Specification", "z3950.Specification_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_attributeSpecifications, + { "attributeSpecifications", "z3950.attributeSpecifications_element", + FT_NONE, BASE_NONE, NULL, 0, + "AttributeCombinations", HFILL }}, + { &hf_z3950_sortType, + { "sortType", "z3950.sortType", + FT_UINT32, BASE_DEC, VALS(z3950_T_sortType_vals), 0, + NULL, HFILL }}, + { &hf_z3950_character, + { "character", "z3950.character_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_sortKeyDetails_sortType_numeric, + { "numeric", "z3950.numeric_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_sortKeyDetails_sortType_structured, + { "structured", "z3950.structured", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_sortKeyDetails_caseSensitivity, + { "caseSensitivity", "z3950.caseSensitivity", + FT_INT32, BASE_DEC, VALS(z3950_T_sortKeyDetails_caseSensitivity_vals), 0, + "T_sortKeyDetails_caseSensitivity", HFILL }}, + { &hf_z3950_processingContext, + { "processingContext", "z3950.processingContext", + FT_INT32, BASE_DEC, VALS(z3950_T_processingContext_vals), 0, + NULL, HFILL }}, + { &hf_z3950_instructions, + { "instructions", "z3950.instructions_element", + FT_NONE, BASE_NONE, NULL, 0, + "EXTERNAL", HFILL }}, + { &hf_z3950_variantSet, + { "variantSet", "z3950.variantSet", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_variantSetInfo_variants, + { "variants", "z3950.variants", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_VariantClass", HFILL }}, + { &hf_z3950_variantSetInfo_variants_item, + { "VariantClass", "z3950.VariantClass_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_variantClass, + { "variantClass", "z3950.variantClass", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_variantTypes, + { "variantTypes", "z3950.variantTypes", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_VariantType", HFILL }}, + { &hf_z3950_variantTypes_item, + { "VariantType", "z3950.VariantType_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_variantType, + { "variantType", "z3950.variantType", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_variantValue, + { "variantValue", "z3950.variantValue_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_values, + { "values", "z3950.values", + FT_UINT32, BASE_DEC, VALS(z3950_ValueSet_vals), 0, + "ValueSet", HFILL }}, + { &hf_z3950_range, + { "range", "z3950.range_element", + FT_NONE, BASE_NONE, NULL, 0, + "ValueRange", HFILL }}, + { &hf_z3950_enumerated, + { "enumerated", "z3950.enumerated", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_ValueDescription", HFILL }}, + { &hf_z3950_enumerated_item, + { "ValueDescription", "z3950.ValueDescription", + FT_UINT32, BASE_DEC, VALS(z3950_ValueDescription_vals), 0, + NULL, HFILL }}, + { &hf_z3950_lower, + { "lower", "z3950.lower", + FT_UINT32, BASE_DEC, VALS(z3950_ValueDescription_vals), 0, + "ValueDescription", HFILL }}, + { &hf_z3950_upper, + { "upper", "z3950.upper", + FT_UINT32, BASE_DEC, VALS(z3950_ValueDescription_vals), 0, + "ValueDescription", HFILL }}, + { &hf_z3950_integer, + { "integer", "z3950.integer", + FT_INT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_octets, + { "octets", "z3950.octets", + FT_BYTES, BASE_NONE, NULL, 0, + "OCTET_STRING", HFILL }}, + { &hf_z3950_valueDescription_unit, + { "unit", "z3950.unit_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_valueAndUnit, + { "valueAndUnit", "z3950.valueAndUnit_element", + FT_NONE, BASE_NONE, NULL, 0, + "IntUnit", HFILL }}, + { &hf_z3950_unitInfo_units, + { "units", "z3950.units", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_UnitType", HFILL }}, + { &hf_z3950_unitInfo_units_item, + { "UnitType", "z3950.UnitType_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_unitType_units, + { "units", "z3950.units", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_Units", HFILL }}, + { &hf_z3950_unitType_units_item, + { "Units", "z3950.Units_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_categories, + { "categories", "z3950.categories", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_CategoryInfo", HFILL }}, + { &hf_z3950_categories_item, + { "CategoryInfo", "z3950.CategoryInfo_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_categoryInfo_category, + { "category", "z3950.category", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_originalCategory, + { "originalCategory", "z3950.originalCategory", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_dateAdded, + { "dateAdded", "z3950.dateAdded", + FT_STRING, BASE_NONE, NULL, 0, + "GeneralizedTime", HFILL }}, + { &hf_z3950_dateChanged, + { "dateChanged", "z3950.dateChanged", + FT_STRING, BASE_NONE, NULL, 0, + "GeneralizedTime", HFILL }}, + { &hf_z3950_expiry, + { "expiry", "z3950.expiry", + FT_STRING, BASE_NONE, NULL, 0, + "GeneralizedTime", HFILL }}, + { &hf_z3950_humanString_Language, + { "humanString-Language", "z3950.humanString_Language", + FT_STRING, BASE_NONE, NULL, 0, + "LanguageCode", HFILL }}, + { &hf_z3950_HumanString_item, + { "HumanString item", "z3950.HumanString_item_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_language, + { "language", "z3950.language", + FT_STRING, BASE_NONE, NULL, 0, + "LanguageCode", HFILL }}, + { &hf_z3950_text, + { "text", "z3950.text", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_IconObject_item, + { "IconObject item", "z3950.IconObject_item_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_bodyType, + { "bodyType", "z3950.bodyType", + FT_UINT32, BASE_DEC, VALS(z3950_T_bodyType_vals), 0, + NULL, HFILL }}, + { &hf_z3950_ianaType, + { "ianaType", "z3950.ianaType", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_z3950type, + { "z3950type", "z3950.z3950type", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_otherType, + { "otherType", "z3950.otherType", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_content, + { "content", "z3950.content", + FT_BYTES, BASE_NONE, NULL, 0, + "OCTET_STRING", HFILL }}, + { &hf_z3950_address, + { "address", "z3950.address", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_email, + { "email", "z3950.email", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_phone, + { "phone", "z3950.phone", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_internetAddress, + { "internetAddress", "z3950.internetAddress_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_hostAddress, + { "hostAddress", "z3950.hostAddress", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_port, + { "port", "z3950.port", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_osiPresentationAddress, + { "osiPresentationAddress", "z3950.osiPresentationAddress_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_pSel, + { "pSel", "z3950.pSel", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_sSel, + { "sSel", "z3950.sSel", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_tSel, + { "tSel", "z3950.tSel", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_nSap, + { "nSap", "z3950.nSap", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_networkAddress_other, + { "other", "z3950.other_element", + FT_NONE, BASE_NONE, NULL, 0, + "T_networkAddress_other", HFILL }}, + { &hf_z3950_networkAddress_other_type, + { "type", "z3950.type", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_networkAddress_other_address, + { "address", "z3950.address", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_queryTypesSupported, + { "queryTypesSupported", "z3950.queryTypesSupported", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_QueryTypeDetails", HFILL }}, + { &hf_z3950_queryTypesSupported_item, + { "QueryTypeDetails", "z3950.QueryTypeDetails", + FT_UINT32, BASE_DEC, VALS(z3950_QueryTypeDetails_vals), 0, + NULL, HFILL }}, + { &hf_z3950_diagnosticsSets, + { "diagnosticsSets", "z3950.diagnosticsSets", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_diagnosticsSets_item, + { "diagnosticsSets item", "z3950.diagnosticsSets_item", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_attributeSetIds, + { "attributeSetIds", "z3950.attributeSetIds", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_AttributeSetId", HFILL }}, + { &hf_z3950_attributeSetIds_item, + { "AttributeSetId", "z3950.AttributeSetId", + FT_OID, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_schemas, + { "schemas", "z3950.schemas", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_schemas_item, + { "schemas item", "z3950.schemas_item", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_recordSyntaxes, + { "recordSyntaxes", "z3950.recordSyntaxes", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_recordSyntaxes_item, + { "recordSyntaxes item", "z3950.recordSyntaxes_item", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_resourceChallenges, + { "resourceChallenges", "z3950.resourceChallenges", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_resourceChallenges_item, + { "resourceChallenges item", "z3950.resourceChallenges_item", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_restrictedAccess, + { "restrictedAccess", "z3950.restrictedAccess", + FT_UINT32, BASE_DEC, NULL, 0, + "AccessRestrictions", HFILL }}, + { &hf_z3950_costInfo, + { "costInfo", "z3950.costInfo_element", + FT_NONE, BASE_NONE, NULL, 0, + "Costs", HFILL }}, + { &hf_z3950_variantSets, + { "variantSets", "z3950.variantSets", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_variantSets_item, + { "variantSets item", "z3950.variantSets_item", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_elementSetNames, + { "elementSetNames", "z3950.elementSetNames", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_ElementSetName", HFILL }}, + { &hf_z3950_elementSetNames_item, + { "ElementSetName", "z3950.ElementSetName", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_unitSystems, + { "unitSystems", "z3950.unitSystems", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_InternationalString", HFILL }}, + { &hf_z3950_unitSystems_item, + { "InternationalString", "z3950.InternationalString", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_queryTypeDetails_private, + { "private", "z3950.private_element", + FT_NONE, BASE_NONE, NULL, 0, + "PrivateCapabilities", HFILL }}, + { &hf_z3950_queryTypeDetails_rpn, + { "rpn", "z3950.rpn_element", + FT_NONE, BASE_NONE, NULL, 0, + "RpnCapabilities", HFILL }}, + { &hf_z3950_iso8777, + { "iso8777", "z3950.iso8777_element", + FT_NONE, BASE_NONE, NULL, 0, + "Iso8777Capabilities", HFILL }}, + { &hf_z3950_z39_58, + { "z39-58", "z3950.z39_58", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_erpn, + { "erpn", "z3950.erpn_element", + FT_NONE, BASE_NONE, NULL, 0, + "RpnCapabilities", HFILL }}, + { &hf_z3950_rankedList, + { "rankedList", "z3950.rankedList", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_privateCapabilities_operators, + { "operators", "z3950.operators", + FT_UINT32, BASE_DEC, NULL, 0, + "T_privateCapabilities_operators", HFILL }}, + { &hf_z3950_privateCapabilities_operators_item, + { "operators item", "z3950.operators_item_element", + FT_NONE, BASE_NONE, NULL, 0, + "T_privateCapabilities_operators_item", HFILL }}, + { &hf_z3950_operator, + { "operator", "z3950.operator", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_searchKeys, + { "searchKeys", "z3950.searchKeys", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_SearchKey", HFILL }}, + { &hf_z3950_searchKeys_item, + { "SearchKey", "z3950.SearchKey_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_privateCapabilities_description, + { "description", "z3950.description", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_HumanString", HFILL }}, + { &hf_z3950_privateCapabilities_description_item, + { "HumanString", "z3950.HumanString", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_operators, + { "operators", "z3950.operators", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_operators_item, + { "operators item", "z3950.operators_item", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_resultSetAsOperandSupported, + { "resultSetAsOperandSupported", "z3950.resultSetAsOperandSupported", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_restrictionOperandSupported, + { "restrictionOperandSupported", "z3950.restrictionOperandSupported", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_proximity, + { "proximity", "z3950.proximity_element", + FT_NONE, BASE_NONE, NULL, 0, + "ProximitySupport", HFILL }}, + { &hf_z3950_anySupport, + { "anySupport", "z3950.anySupport", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_unitsSupported, + { "unitsSupported", "z3950.unitsSupported", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_unitsSupported_item, + { "unitsSupported item", "z3950.unitsSupported_item", + FT_UINT32, BASE_DEC, VALS(z3950_T_unitsSupported_item_vals), 0, + NULL, HFILL }}, + { &hf_z3950_proximitySupport_unitsSupported_item_known, + { "known", "z3950.known", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_proximitySupport_unitsSupported_item_private, + { "private", "z3950.private_element", + FT_NONE, BASE_NONE, NULL, 0, + "T_proximitySupport_unitsSupported_item_private", HFILL }}, + { &hf_z3950_proximitySupport_unitsSupported_item_private_unit, + { "unit", "z3950.unit", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_searchKey, + { "searchKey", "z3950.searchKey", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_AccessRestrictions_item, + { "AccessRestrictions item", "z3950.AccessRestrictions_item_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_accessType, + { "accessType", "z3950.accessType", + FT_INT32, BASE_DEC, VALS(z3950_T_accessType_vals), 0, + NULL, HFILL }}, + { &hf_z3950_accessText, + { "accessText", "z3950.accessText", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_accessChallenges, + { "accessChallenges", "z3950.accessChallenges", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_accessChallenges_item, + { "accessChallenges item", "z3950.accessChallenges_item", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_connectCharge, + { "connectCharge", "z3950.connectCharge_element", + FT_NONE, BASE_NONE, NULL, 0, + "Charge", HFILL }}, + { &hf_z3950_connectTime, + { "connectTime", "z3950.connectTime_element", + FT_NONE, BASE_NONE, NULL, 0, + "Charge", HFILL }}, + { &hf_z3950_displayCharge, + { "displayCharge", "z3950.displayCharge_element", + FT_NONE, BASE_NONE, NULL, 0, + "Charge", HFILL }}, + { &hf_z3950_searchCharge, + { "searchCharge", "z3950.searchCharge_element", + FT_NONE, BASE_NONE, NULL, 0, + "Charge", HFILL }}, + { &hf_z3950_subscriptCharge, + { "subscriptCharge", "z3950.subscriptCharge_element", + FT_NONE, BASE_NONE, NULL, 0, + "Charge", HFILL }}, + { &hf_z3950_otherCharges, + { "otherCharges", "z3950.otherCharges", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_otherCharges_item, + { "otherCharges item", "z3950.otherCharges_item_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_forWhat, + { "forWhat", "z3950.forWhat", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_charge, + { "charge", "z3950.charge_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_cost, + { "cost", "z3950.cost_element", + FT_NONE, BASE_NONE, NULL, 0, + "IntUnit", HFILL }}, + { &hf_z3950_perWhat, + { "perWhat", "z3950.perWhat_element", + FT_NONE, BASE_NONE, NULL, 0, + "Unit", HFILL }}, + { &hf_z3950_charge_text, + { "text", "z3950.text", + FT_UINT32, BASE_DEC, NULL, 0, + "HumanString", HFILL }}, + { &hf_z3950_DatabaseList_item, + { "DatabaseName", "z3950.DatabaseName", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_defaultAttributeSet, + { "defaultAttributeSet", "z3950.defaultAttributeSet", + FT_OID, BASE_NONE, NULL, 0, + "AttributeSetId", HFILL }}, + { &hf_z3950_legalCombinations, + { "legalCombinations", "z3950.legalCombinations", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_AttributeCombination", HFILL }}, + { &hf_z3950_legalCombinations_item, + { "AttributeCombination", "z3950.AttributeCombination", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_AttributeCombination_item, + { "AttributeOccurrence", "z3950.AttributeOccurrence_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_mustBeSupplied, + { "mustBeSupplied", "z3950.mustBeSupplied_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_attributeOccurrence_attributeValues, + { "attributeValues", "z3950.attributeValues", + FT_UINT32, BASE_DEC, VALS(z3950_T_attributeOccurrence_attributeValues_vals), 0, + "T_attributeOccurrence_attributeValues", HFILL }}, + { &hf_z3950_any_or_none, + { "any-or-none", "z3950.any_or_none_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_specific, + { "specific", "z3950.specific", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_StringOrNumeric", HFILL }}, + { &hf_z3950_specific_item, + { "StringOrNumeric", "z3950.StringOrNumeric", + FT_UINT32, BASE_DEC, VALS(z3950_StringOrNumeric_vals), 0, + NULL, HFILL }}, + { &hf_z3950_briefBib_title, + { "title", "z3950.title", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_author, + { "author", "z3950.author", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_recordType, + { "recordType", "z3950.recordType", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_bibliographicLevel, + { "bibliographicLevel", "z3950.bibliographicLevel", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_briefBib_format, + { "format", "z3950.format", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_FormatSpec", HFILL }}, + { &hf_z3950_briefBib_format_item, + { "FormatSpec", "z3950.FormatSpec_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_publicationPlace, + { "publicationPlace", "z3950.publicationPlace", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_publicationDate, + { "publicationDate", "z3950.publicationDate", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_targetSystemKey, + { "targetSystemKey", "z3950.targetSystemKey", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_satisfyingElement, + { "satisfyingElement", "z3950.satisfyingElement", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_rank, + { "rank", "z3950.rank", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_documentId, + { "documentId", "z3950.documentId", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_abstract, + { "abstract", "z3950.abstract", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_formatSpec_type, + { "type", "z3950.type", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_size, + { "size", "z3950.size", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_bestPosn, + { "bestPosn", "z3950.bestPosn", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_GenericRecord_item, + { "TaggedElement", "z3950.TaggedElement_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_tagOccurrence, + { "tagOccurrence", "z3950.tagOccurrence", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_taggedElement_content, + { "content", "z3950.content", + FT_UINT32, BASE_DEC, VALS(z3950_ElementData_vals), 0, + "ElementData", HFILL }}, + { &hf_z3950_metaData, + { "metaData", "z3950.metaData_element", + FT_NONE, BASE_NONE, NULL, 0, + "ElementMetaData", HFILL }}, + { &hf_z3950_appliedVariant, + { "appliedVariant", "z3950.appliedVariant_element", + FT_NONE, BASE_NONE, NULL, 0, + "Variant", HFILL }}, + { &hf_z3950_date, + { "date", "z3950.date", + FT_STRING, BASE_NONE, NULL, 0, + "GeneralizedTime", HFILL }}, + { &hf_z3950_ext, + { "ext", "z3950.ext_element", + FT_NONE, BASE_NONE, NULL, 0, + "EXTERNAL", HFILL }}, + { &hf_z3950_trueOrFalse, + { "trueOrFalse", "z3950.trueOrFalse", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_intUnit, + { "intUnit", "z3950.intUnit_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_elementNotThere, + { "elementNotThere", "z3950.elementNotThere_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_elementEmpty, + { "elementEmpty", "z3950.elementEmpty_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_noDataRequested, + { "noDataRequested", "z3950.noDataRequested_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_elementData_diagnostic, + { "diagnostic", "z3950.diagnostic_element", + FT_NONE, BASE_NONE, NULL, 0, + "EXTERNAL", HFILL }}, + { &hf_z3950_subtree, + { "subtree", "z3950.subtree", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_TaggedElement", HFILL }}, + { &hf_z3950_subtree_item, + { "TaggedElement", "z3950.TaggedElement_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_seriesOrder, + { "seriesOrder", "z3950.seriesOrder_element", + FT_NONE, BASE_NONE, NULL, 0, + "Order", HFILL }}, + { &hf_z3950_usageRight, + { "usageRight", "z3950.usageRight_element", + FT_NONE, BASE_NONE, NULL, 0, + "Usage", HFILL }}, + { &hf_z3950_hits, + { "hits", "z3950.hits", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_HitVector", HFILL }}, + { &hf_z3950_hits_item, + { "HitVector", "z3950.HitVector_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_displayName, + { "displayName", "z3950.displayName", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_supportedVariants, + { "supportedVariants", "z3950.supportedVariants", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_Variant", HFILL }}, + { &hf_z3950_supportedVariants_item, + { "Variant", "z3950.Variant_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_elementDescriptor, + { "elementDescriptor", "z3950.elementDescriptor", + FT_BYTES, BASE_NONE, NULL, 0, + "OCTET_STRING", HFILL }}, + { &hf_z3950_surrogateFor, + { "surrogateFor", "z3950.surrogateFor", + FT_UINT32, BASE_DEC, NULL, 0, + "TagPath", HFILL }}, + { &hf_z3950_surrogateElement, + { "surrogateElement", "z3950.surrogateElement", + FT_UINT32, BASE_DEC, NULL, 0, + "TagPath", HFILL }}, + { &hf_z3950_TagPath_item, + { "TagPath item", "z3950.TagPath_item_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_ascending, + { "ascending", "z3950.ascending", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_order, + { "order", "z3950.order", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_usage_type, + { "type", "z3950.type", + FT_INT32, BASE_DEC, VALS(z3950_T_usage_type_vals), 0, + "T_usage_type", HFILL }}, + { &hf_z3950_restriction, + { "restriction", "z3950.restriction", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_satisfier, + { "satisfier", "z3950.satisfier", + FT_UINT32, BASE_DEC, VALS(z3950_Term_vals), 0, + "Term", HFILL }}, + { &hf_z3950_offsetIntoElement, + { "offsetIntoElement", "z3950.offsetIntoElement_element", + FT_NONE, BASE_NONE, NULL, 0, + "IntUnit", HFILL }}, + { &hf_z3950_length, + { "length", "z3950.length_element", + FT_NONE, BASE_NONE, NULL, 0, + "IntUnit", HFILL }}, + { &hf_z3950_hitRank, + { "hitRank", "z3950.hitRank", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_targetToken, + { "targetToken", "z3950.targetToken", + FT_BYTES, BASE_NONE, NULL, 0, + "OCTET_STRING", HFILL }}, + { &hf_z3950_globalVariantSetId, + { "globalVariantSetId", "z3950.globalVariantSetId", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_triples, + { "triples", "z3950.triples", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_triples_item, + { "triples item", "z3950.triples_item_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_variantSetId, + { "variantSetId", "z3950.variantSetId", + FT_OID, BASE_NONE, NULL, 0, + "OBJECT_IDENTIFIER", HFILL }}, + { &hf_z3950_class, + { "class", "z3950.class", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_variant_triples_item_value, + { "value", "z3950.value", + FT_UINT32, BASE_DEC, VALS(z3950_T_variant_triples_item_value_vals), 0, + "T_variant_triples_item_value", HFILL }}, + { &hf_z3950_octetString, + { "octetString", "z3950.octetString", + FT_BYTES, BASE_NONE, NULL, 0, + "OCTET_STRING", HFILL }}, + { &hf_z3950_boolean, + { "boolean", "z3950.boolean", + FT_BOOLEAN, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_variant_triples_item_value_unit, + { "unit", "z3950.unit_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_taskPackage_description, + { "description", "z3950.description", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_targetReference, + { "targetReference", "z3950.targetReference", + FT_BYTES, BASE_NONE, NULL, 0, + "OCTET_STRING", HFILL }}, + { &hf_z3950_creationDateTime, + { "creationDateTime", "z3950.creationDateTime", + FT_STRING, BASE_NONE, NULL, 0, + "GeneralizedTime", HFILL }}, + { &hf_z3950_taskStatus, + { "taskStatus", "z3950.taskStatus", + FT_INT32, BASE_DEC, VALS(z3950_T_taskStatus_vals), 0, + NULL, HFILL }}, + { &hf_z3950_packageDiagnostics, + { "packageDiagnostics", "z3950.packageDiagnostics", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_DiagRec", HFILL }}, + { &hf_z3950_packageDiagnostics_item, + { "DiagRec", "z3950.DiagRec", + FT_UINT32, BASE_DEC, VALS(z3950_DiagRec_vals), 0, + NULL, HFILL }}, + { &hf_z3950_challenge, + { "challenge", "z3950.challenge", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_response, + { "response", "z3950.response", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_Challenge_item, + { "Challenge item", "z3950.Challenge_item_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_promptId, + { "promptId", "z3950.promptId", + FT_UINT32, BASE_DEC, VALS(z3950_PromptId_vals), 0, + NULL, HFILL }}, + { &hf_z3950_defaultResponse, + { "defaultResponse", "z3950.defaultResponse", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_promptInfo, + { "promptInfo", "z3950.promptInfo", + FT_UINT32, BASE_DEC, VALS(z3950_T_promptInfo_vals), 0, + NULL, HFILL }}, + { &hf_z3950_challenge_item_promptInfo_character, + { "character", "z3950.character", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_encrypted, + { "encrypted", "z3950.encrypted_element", + FT_NONE, BASE_NONE, NULL, 0, + "Encryption", HFILL }}, + { &hf_z3950_regExpr, + { "regExpr", "z3950.regExpr", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_responseRequired, + { "responseRequired", "z3950.responseRequired_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_allowedValues, + { "allowedValues", "z3950.allowedValues", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_InternationalString", HFILL }}, + { &hf_z3950_allowedValues_item, + { "InternationalString", "z3950.InternationalString", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_shouldSave, + { "shouldSave", "z3950.shouldSave_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_challenge_item_dataType, + { "dataType", "z3950.dataType", + FT_INT32, BASE_DEC, VALS(z3950_T_challenge_item_dataType_vals), 0, + "T_challenge_item_dataType", HFILL }}, + { &hf_z3950_challenge_item_diagnostic, + { "diagnostic", "z3950.diagnostic_element", + FT_NONE, BASE_NONE, NULL, 0, + "EXTERNAL", HFILL }}, + { &hf_z3950_Response_item, + { "Response item", "z3950.Response_item_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_promptResponse, + { "promptResponse", "z3950.promptResponse", + FT_UINT32, BASE_DEC, VALS(z3950_T_promptResponse_vals), 0, + NULL, HFILL }}, + { &hf_z3950_accept, + { "accept", "z3950.accept", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_acknowledge, + { "acknowledge", "z3950.acknowledge_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_enummeratedPrompt, + { "enummeratedPrompt", "z3950.enummeratedPrompt_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_promptId_enummeratedPrompt_type, + { "type", "z3950.type", + FT_INT32, BASE_DEC, VALS(z3950_T_promptId_enummeratedPrompt_type_vals), 0, + "T_promptId_enummeratedPrompt_type", HFILL }}, + { &hf_z3950_suggestedString, + { "suggestedString", "z3950.suggestedString", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_nonEnumeratedPrompt, + { "nonEnumeratedPrompt", "z3950.nonEnumeratedPrompt", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_cryptType, + { "cryptType", "z3950.cryptType", + FT_BYTES, BASE_NONE, NULL, 0, + "OCTET_STRING", HFILL }}, + { &hf_z3950_credential, + { "credential", "z3950.credential", + FT_BYTES, BASE_NONE, NULL, 0, + "OCTET_STRING", HFILL }}, + { &hf_z3950_data, + { "data", "z3950.data", + FT_BYTES, BASE_NONE, NULL, 0, + "OCTET_STRING", HFILL }}, + { &hf_z3950_dES_RN_Object_challenge, + { "challenge", "z3950.challenge_element", + FT_NONE, BASE_NONE, NULL, 0, + "DRNType", HFILL }}, + { &hf_z3950_rES_RN_Object_response, + { "response", "z3950.response_element", + FT_NONE, BASE_NONE, NULL, 0, + "DRNType", HFILL }}, + { &hf_z3950_dRNType_userId, + { "userId", "z3950.userId", + FT_BYTES, BASE_NONE, NULL, 0, + "OCTET_STRING", HFILL }}, + { &hf_z3950_salt, + { "salt", "z3950.salt", + FT_BYTES, BASE_NONE, NULL, 0, + "OCTET_STRING", HFILL }}, + { &hf_z3950_randomNumber, + { "randomNumber", "z3950.randomNumber", + FT_BYTES, BASE_NONE, NULL, 0, + "OCTET_STRING", HFILL }}, + { &hf_z3950_kRBObject_challenge, + { "challenge", "z3950.challenge_element", + FT_NONE, BASE_NONE, NULL, 0, + "KRBRequest", HFILL }}, + { &hf_z3950_kRBObject_response, + { "response", "z3950.response_element", + FT_NONE, BASE_NONE, NULL, 0, + "KRBResponse", HFILL }}, + { &hf_z3950_service, + { "service", "z3950.service", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_instance, + { "instance", "z3950.instance", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_realm, + { "realm", "z3950.realm", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_userid, + { "userid", "z3950.userid", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_ticket, + { "ticket", "z3950.ticket", + FT_BYTES, BASE_NONE, NULL, 0, + "OCTET_STRING", HFILL }}, + { &hf_z3950_SearchInfoReport_item, + { "SearchInfoReport item", "z3950.SearchInfoReport_item_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_subqueryId, + { "subqueryId", "z3950.subqueryId", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_fullQuery, + { "fullQuery", "z3950.fullQuery", + FT_BOOLEAN, BASE_NONE, NULL, 0, + "BOOLEAN", HFILL }}, + { &hf_z3950_subqueryExpression, + { "subqueryExpression", "z3950.subqueryExpression", + FT_UINT32, BASE_DEC, VALS(z3950_QueryExpression_vals), 0, + "QueryExpression", HFILL }}, + { &hf_z3950_subqueryInterpretation, + { "subqueryInterpretation", "z3950.subqueryInterpretation", + FT_UINT32, BASE_DEC, VALS(z3950_QueryExpression_vals), 0, + "QueryExpression", HFILL }}, + { &hf_z3950_subqueryRecommendation, + { "subqueryRecommendation", "z3950.subqueryRecommendation", + FT_UINT32, BASE_DEC, VALS(z3950_QueryExpression_vals), 0, + "QueryExpression", HFILL }}, + { &hf_z3950_subqueryCount, + { "subqueryCount", "z3950.subqueryCount", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_subqueryWeight, + { "subqueryWeight", "z3950.subqueryWeight_element", + FT_NONE, BASE_NONE, NULL, 0, + "IntUnit", HFILL }}, + { &hf_z3950_resultsByDB, + { "resultsByDB", "z3950.resultsByDB", + FT_UINT32, BASE_DEC, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_ResultsByDB_item, + { "ResultsByDB item", "z3950.ResultsByDB_item_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_databases, + { "databases", "z3950.databases", + FT_UINT32, BASE_DEC, VALS(z3950_T_databases_vals), 0, + NULL, HFILL }}, + { &hf_z3950_all, + { "all", "z3950.all_element", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_list, + { "list", "z3950.list", + FT_UINT32, BASE_DEC, NULL, 0, + "SEQUENCE_OF_DatabaseName", HFILL }}, + { &hf_z3950_list_item, + { "DatabaseName", "z3950.DatabaseName", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_count, + { "count", "z3950.count", + FT_INT32, BASE_DEC, NULL, 0, + "INTEGER", HFILL }}, + { &hf_z3950_queryExpression_term, + { "term", "z3950.term_element", + FT_NONE, BASE_NONE, NULL, 0, + "T_queryExpression_term", HFILL }}, + { &hf_z3950_queryTerm, + { "queryTerm", "z3950.queryTerm", + FT_UINT32, BASE_DEC, VALS(z3950_Term_vals), 0, + "Term", HFILL }}, + { &hf_z3950_termComment, + { "termComment", "z3950.termComment", + FT_STRING, BASE_NONE, NULL, 0, + "InternationalString", HFILL }}, + { &hf_z3950_ProtocolVersion_U_version_1, + { "version-1", "z3950.version-1", + FT_BOOLEAN, 8, NULL, 0x80, + NULL, HFILL }}, + { &hf_z3950_ProtocolVersion_U_version_2, + { "version-2", "z3950.version-2", + FT_BOOLEAN, 8, NULL, 0x40, + NULL, HFILL }}, + { &hf_z3950_ProtocolVersion_U_version_3, + { "version-3", "z3950.version-3", + FT_BOOLEAN, 8, NULL, 0x20, + NULL, HFILL }}, + { &hf_z3950_Options_U_search, + { "search", "z3950.search", + FT_BOOLEAN, 8, NULL, 0x80, + NULL, HFILL }}, + { &hf_z3950_Options_U_present, + { "present", "z3950.present", + FT_BOOLEAN, 8, NULL, 0x40, + NULL, HFILL }}, + { &hf_z3950_Options_U_delSet, + { "delSet", "z3950.delSet", + FT_BOOLEAN, 8, NULL, 0x20, + NULL, HFILL }}, + { &hf_z3950_Options_U_resourceReport, + { "resourceReport", "z3950.resourceReport", + FT_BOOLEAN, 8, NULL, 0x10, + NULL, HFILL }}, + { &hf_z3950_Options_U_triggerResourceCtrl, + { "triggerResourceCtrl", "z3950.triggerResourceCtrl", + FT_BOOLEAN, 8, NULL, 0x08, + NULL, HFILL }}, + { &hf_z3950_Options_U_resourceCtrl, + { "resourceCtrl", "z3950.resourceCtrl", + FT_BOOLEAN, 8, NULL, 0x04, + NULL, HFILL }}, + { &hf_z3950_Options_U_accessCtrl, + { "accessCtrl", "z3950.accessCtrl", + FT_BOOLEAN, 8, NULL, 0x02, + NULL, HFILL }}, + { &hf_z3950_Options_U_scan, + { "scan", "z3950.scan", + FT_BOOLEAN, 8, NULL, 0x01, + NULL, HFILL }}, + { &hf_z3950_Options_U_sort, + { "sort", "z3950.sort", + FT_BOOLEAN, 8, NULL, 0x80, + NULL, HFILL }}, + { &hf_z3950_Options_U_extendedServices, + { "extendedServices", "z3950.extendedServices", + FT_BOOLEAN, 8, NULL, 0x20, + NULL, HFILL }}, + { &hf_z3950_Options_U_level_1Segmentation, + { "level-1Segmentation", "z3950.level-1Segmentation", + FT_BOOLEAN, 8, NULL, 0x10, + NULL, HFILL }}, + { &hf_z3950_Options_U_level_2Segmentation, + { "level-2Segmentation", "z3950.level-2Segmentation", + FT_BOOLEAN, 8, NULL, 0x08, + NULL, HFILL }}, + { &hf_z3950_Options_U_concurrentOperations, + { "concurrentOperations", "z3950.concurrentOperations", + FT_BOOLEAN, 8, NULL, 0x04, + NULL, HFILL }}, + { &hf_z3950_Options_U_namedResultSets, + { "namedResultSets", "z3950.namedResultSets", + FT_BOOLEAN, 8, NULL, 0x02, + NULL, HFILL }}, + +/*--- End of included file: packet-z3950-hfarr.c ---*/ +#line 981 "./asn1/z3950/packet-z3950-template.c" + + { &hf_z3950_referenceId_printable, + { "referenceId", "z3950.referenceId.printable", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_z3950_general_printable, + { "general", "z3950.general.printable", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + +/* MARC hf definitions */ + { &hf_marc_record, + { "MARC record", "marc", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_record_terminator, + { "MARC record terminator", "marc.terminator", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader, + { "MARC leader", "marc.leader", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_length, + { "MARC leader length", "marc.leader.length", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_status, + { "MARC leader status", "marc.leader.status", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_type, + { "MARC leader type", "marc.leader.type", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_biblevel, + { "MARC leader biblevel", "marc.leader.biblevel", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_control, + { "MARC leader control", "marc.leader.control", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_encoding, + { "MARC leader encoding", "marc.leader.encoding", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_indicator_count, + { "MARC leader indicator count", "marc.leader.indicator_count", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_subfield_count, + { "MARC leader subfield count", "marc.leader.subfield_count", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_data_offset, + { "MARC leader data offset", "marc.leader.data_offset", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_encoding_level, + { "MARC leader encoding level", "marc.leader.encoding_level", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_descriptive_cataloging, + { "MARC leader descriptive cataloging", "marc.leader.descriptive_cataloging", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_multipart_level, + { "MARC leader multipart level", "marc.leader.multipart_level", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_length_of_field_length, + { "MARC leader length-of-field length", "marc.leader.length_of_field_length", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_starting_character_position_length, + { "MARC leader starting-character-position length", "marc.leader.starting_character_position_length", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_leader_implementation_defined_length, + { "MARC leader implementation-defined length", "marc.leader.implementation_defined_length", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_directory, + { "MARC directory", "marc.directory", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_directory_entry, + { "MARC directory entry", "marc.directory.entry", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_directory_entry_tag, + { "tag", "marc.directory.entry.tag", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_directory_entry_length, + { "length", "marc.directory.entry.length", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_directory_entry_starting_position, + { "starting position", "marc.directory.entry.starting_position", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_directory_terminator, + { "MARC directory terminator", "marc.directory.terminator", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_fields, + { "MARC data fields", "marc.fields", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_field, + { "MARC field", "marc.field", + FT_NONE, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_field_control, + { "Control field", "marc.field.control", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + { &hf_marc_field_terminator, + { "MARC field terminator", "marc.field.terminator", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_field_indicator1, + { "MARC field indicator1", "marc.field.indicator1", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_field_indicator2, + { "MARC field indicator2", "marc.field.indicator2", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_field_subfield_indicator, + { "MARC field subfield indicator", "marc.field.subfield.indicator", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_field_subfield_tag, + { "MARC field subfield tag", "marc.field.subfield.tag", + FT_CHAR, BASE_HEX, NULL, 0, + NULL, HFILL }}, + { &hf_marc_field_subfield, + { "MARC Subfield", "marc.field.subfield", + FT_STRING, BASE_NONE, NULL, 0, + NULL, HFILL }}, + + }; + + /* List of subtrees */ + static gint *ett[] = { + &ett_z3950, +/* MARC etts */ + &ett_marc_record, + &ett_marc_leader, + &ett_marc_directory, + &ett_marc_directory_entry, + &ett_marc_fields, + &ett_marc_field, + +/*--- Included file: packet-z3950-ettarr.c ---*/ +#line 1 "./asn1/z3950/packet-z3950-ettarr.c" + &ett_z3950_PDU, + &ett_z3950_InitializeRequest, + &ett_z3950_T_idAuthentication, + &ett_z3950_T_idPass, + &ett_z3950_InitializeResponse, + &ett_z3950_ProtocolVersion_U, + &ett_z3950_Options_U, + &ett_z3950_SearchRequest, + &ett_z3950_SEQUENCE_OF_DatabaseName, + &ett_z3950_Query, + &ett_z3950_RPNQuery, + &ett_z3950_RPNStructure, + &ett_z3950_T_rpnRpnOp, + &ett_z3950_Operand, + &ett_z3950_AttributesPlusTerm_U, + &ett_z3950_ResultSetPlusAttributes_U, + &ett_z3950_SEQUENCE_OF_AttributeElement, + &ett_z3950_Term, + &ett_z3950_Operator_U, + &ett_z3950_AttributeElement, + &ett_z3950_T_attributeValue, + &ett_z3950_T_attributeValue_complex, + &ett_z3950_SEQUENCE_OF_StringOrNumeric, + &ett_z3950_T_semanticAction, + &ett_z3950_ProximityOperator, + &ett_z3950_T_proximityUnitCode, + &ett_z3950_SearchResponse, + &ett_z3950_PresentRequest, + &ett_z3950_SEQUENCE_OF_Range, + &ett_z3950_T_recordComposition, + &ett_z3950_Segment, + &ett_z3950_SEQUENCE_OF_NamePlusRecord, + &ett_z3950_PresentResponse, + &ett_z3950_Records, + &ett_z3950_SEQUENCE_OF_DiagRec, + &ett_z3950_NamePlusRecord, + &ett_z3950_T_record, + &ett_z3950_FragmentSyntax, + &ett_z3950_DiagRec, + &ett_z3950_DefaultDiagFormat, + &ett_z3950_T_addinfo, + &ett_z3950_Range, + &ett_z3950_ElementSetNames, + &ett_z3950_T_databaseSpecific, + &ett_z3950_T_databaseSpecific_item, + &ett_z3950_CompSpec, + &ett_z3950_T_dbSpecific, + &ett_z3950_T_dbSpecific_item, + &ett_z3950_T_compSpec_recordSyntax, + &ett_z3950_Specification, + &ett_z3950_T_specification_elementSpec, + &ett_z3950_DeleteResultSetRequest, + &ett_z3950_SEQUENCE_OF_ResultSetId, + &ett_z3950_DeleteResultSetResponse, + &ett_z3950_ListStatuses, + &ett_z3950_ListStatuses_item, + &ett_z3950_AccessControlRequest, + &ett_z3950_T_securityChallenge, + &ett_z3950_AccessControlResponse, + &ett_z3950_T_securityChallengeResponse, + &ett_z3950_ResourceControlRequest, + &ett_z3950_ResourceControlResponse, + &ett_z3950_TriggerResourceControlRequest, + &ett_z3950_ResourceReportRequest, + &ett_z3950_ResourceReportResponse, + &ett_z3950_ScanRequest, + &ett_z3950_ScanResponse, + &ett_z3950_ListEntries, + &ett_z3950_SEQUENCE_OF_Entry, + &ett_z3950_Entry, + &ett_z3950_TermInfo, + &ett_z3950_SEQUENCE_OF_AttributesPlusTerm, + &ett_z3950_OccurrenceByAttributes, + &ett_z3950_OccurrenceByAttributes_item, + &ett_z3950_T_occurrences, + &ett_z3950_T_byDatabase, + &ett_z3950_T_byDatabase_item, + &ett_z3950_SortRequest, + &ett_z3950_SEQUENCE_OF_InternationalString, + &ett_z3950_SEQUENCE_OF_SortKeySpec, + &ett_z3950_SortResponse, + &ett_z3950_SortKeySpec, + &ett_z3950_T_missingValueAction, + &ett_z3950_SortElement, + &ett_z3950_T_datbaseSpecific, + &ett_z3950_T_datbaseSpecific_item, + &ett_z3950_SortKey, + &ett_z3950_T_sortAttributes, + &ett_z3950_ExtendedServicesRequest, + &ett_z3950_ExtendedServicesResponse, + &ett_z3950_Permissions, + &ett_z3950_Permissions_item, + &ett_z3950_T_allowableFunctions, + &ett_z3950_Close, + &ett_z3950_OtherInformation_U, + &ett_z3950_T__untag_item, + &ett_z3950_T_information, + &ett_z3950_InfoCategory, + &ett_z3950_IntUnit, + &ett_z3950_Unit, + &ett_z3950_StringOrNumeric, + &ett_z3950_OCLC_UserInformation, + &ett_z3950_SEQUENCE_OF_DBName, + &ett_z3950_OPACRecord, + &ett_z3950_SEQUENCE_OF_HoldingsRecord, + &ett_z3950_HoldingsRecord, + &ett_z3950_HoldingsAndCircData, + &ett_z3950_SEQUENCE_OF_Volume, + &ett_z3950_SEQUENCE_OF_CircRecord, + &ett_z3950_Volume, + &ett_z3950_CircRecord, + &ett_z3950_DiagnosticFormat, + &ett_z3950_DiagnosticFormat_item, + &ett_z3950_T_diagnosticFormat_item_diagnostic, + &ett_z3950_DiagFormat, + &ett_z3950_T_tooMany, + &ett_z3950_T_badSpec, + &ett_z3950_SEQUENCE_OF_Specification, + &ett_z3950_T_dbUnavail, + &ett_z3950_T_why, + &ett_z3950_T_attribute, + &ett_z3950_T_attCombo, + &ett_z3950_SEQUENCE_OF_AttributeList, + &ett_z3950_T_diagFormat_term, + &ett_z3950_T_diagFormat_proximity, + &ett_z3950_T_scan, + &ett_z3950_T_sort, + &ett_z3950_T_segmentation, + &ett_z3950_T_extServices, + &ett_z3950_T_accessCtrl, + &ett_z3950_T_diagFormat_accessCtrl_oid, + &ett_z3950_T_alternative, + &ett_z3950_T_diagFormat_recordSyntax, + &ett_z3950_T_suggestedAlternatives, + &ett_z3950_Explain_Record, + &ett_z3950_TargetInfo, + &ett_z3950_SEQUENCE_OF_DatabaseList, + &ett_z3950_SEQUENCE_OF_NetworkAddress, + &ett_z3950_DatabaseInfo, + &ett_z3950_SEQUENCE_OF_HumanString, + &ett_z3950_T_recordCount, + &ett_z3950_SchemaInfo, + &ett_z3950_T_tagTypeMapping, + &ett_z3950_T_tagTypeMapping_item, + &ett_z3950_SEQUENCE_OF_ElementInfo, + &ett_z3950_ElementInfo, + &ett_z3950_Path, + &ett_z3950_Path_item, + &ett_z3950_ElementDataType, + &ett_z3950_TagSetInfo, + &ett_z3950_T_tagSetInfo_elements, + &ett_z3950_T_tagSetInfo_elements_item, + &ett_z3950_RecordSyntaxInfo, + &ett_z3950_T_transferSyntaxes, + &ett_z3950_AttributeSetInfo, + &ett_z3950_SEQUENCE_OF_AttributeType, + &ett_z3950_AttributeType, + &ett_z3950_SEQUENCE_OF_AttributeDescription, + &ett_z3950_AttributeDescription, + &ett_z3950_TermListInfo, + &ett_z3950_T_termLists, + &ett_z3950_T_termLists_item, + &ett_z3950_ExtendedServicesInfo, + &ett_z3950_AttributeDetails, + &ett_z3950_SEQUENCE_OF_AttributeSetDetails, + &ett_z3950_AttributeSetDetails, + &ett_z3950_SEQUENCE_OF_AttributeTypeDetails, + &ett_z3950_AttributeTypeDetails, + &ett_z3950_SEQUENCE_OF_AttributeValue, + &ett_z3950_OmittedAttributeInterpretation, + &ett_z3950_AttributeValue, + &ett_z3950_TermListDetails, + &ett_z3950_T_scanInfo, + &ett_z3950_SEQUENCE_OF_Term, + &ett_z3950_ElementSetDetails, + &ett_z3950_SEQUENCE_OF_PerElementDetails, + &ett_z3950_RetrievalRecordDetails, + &ett_z3950_PerElementDetails, + &ett_z3950_SEQUENCE_OF_Path, + &ett_z3950_RecordTag, + &ett_z3950_SortDetails, + &ett_z3950_SEQUENCE_OF_SortKeyDetails, + &ett_z3950_SortKeyDetails, + &ett_z3950_T_sortType, + &ett_z3950_ProcessingInformation, + &ett_z3950_VariantSetInfo, + &ett_z3950_SEQUENCE_OF_VariantClass, + &ett_z3950_VariantClass, + &ett_z3950_SEQUENCE_OF_VariantType, + &ett_z3950_VariantType, + &ett_z3950_VariantValue, + &ett_z3950_ValueSet, + &ett_z3950_SEQUENCE_OF_ValueDescription, + &ett_z3950_ValueRange, + &ett_z3950_ValueDescription, + &ett_z3950_UnitInfo, + &ett_z3950_SEQUENCE_OF_UnitType, + &ett_z3950_UnitType, + &ett_z3950_SEQUENCE_OF_Units, + &ett_z3950_Units, + &ett_z3950_CategoryList, + &ett_z3950_SEQUENCE_OF_CategoryInfo, + &ett_z3950_CategoryInfo, + &ett_z3950_CommonInfo, + &ett_z3950_HumanString, + &ett_z3950_HumanString_item, + &ett_z3950_IconObject, + &ett_z3950_IconObject_item, + &ett_z3950_T_bodyType, + &ett_z3950_ContactInfo, + &ett_z3950_NetworkAddress, + &ett_z3950_T_internetAddress, + &ett_z3950_T_osiPresentationAddress, + &ett_z3950_T_networkAddress_other, + &ett_z3950_AccessInfo, + &ett_z3950_SEQUENCE_OF_QueryTypeDetails, + &ett_z3950_T_diagnosticsSets, + &ett_z3950_SEQUENCE_OF_AttributeSetId, + &ett_z3950_T_schemas, + &ett_z3950_T_recordSyntaxes, + &ett_z3950_T_resourceChallenges, + &ett_z3950_T_variantSets, + &ett_z3950_SEQUENCE_OF_ElementSetName, + &ett_z3950_QueryTypeDetails, + &ett_z3950_PrivateCapabilities, + &ett_z3950_T_privateCapabilities_operators, + &ett_z3950_T_privateCapabilities_operators_item, + &ett_z3950_SEQUENCE_OF_SearchKey, + &ett_z3950_RpnCapabilities, + &ett_z3950_T_operators, + &ett_z3950_Iso8777Capabilities, + &ett_z3950_ProximitySupport, + &ett_z3950_T_unitsSupported, + &ett_z3950_T_unitsSupported_item, + &ett_z3950_T_proximitySupport_unitsSupported_item_private, + &ett_z3950_SearchKey, + &ett_z3950_AccessRestrictions, + &ett_z3950_AccessRestrictions_item, + &ett_z3950_T_accessChallenges, + &ett_z3950_Costs, + &ett_z3950_T_otherCharges, + &ett_z3950_T_otherCharges_item, + &ett_z3950_Charge, + &ett_z3950_DatabaseList, + &ett_z3950_AttributeCombinations, + &ett_z3950_SEQUENCE_OF_AttributeCombination, + &ett_z3950_AttributeCombination, + &ett_z3950_AttributeOccurrence, + &ett_z3950_T_attributeOccurrence_attributeValues, + &ett_z3950_BriefBib, + &ett_z3950_SEQUENCE_OF_FormatSpec, + &ett_z3950_FormatSpec, + &ett_z3950_GenericRecord, + &ett_z3950_TaggedElement, + &ett_z3950_ElementData, + &ett_z3950_SEQUENCE_OF_TaggedElement, + &ett_z3950_ElementMetaData, + &ett_z3950_SEQUENCE_OF_HitVector, + &ett_z3950_SEQUENCE_OF_Variant, + &ett_z3950_TagPath, + &ett_z3950_TagPath_item, + &ett_z3950_Order, + &ett_z3950_Usage, + &ett_z3950_HitVector, + &ett_z3950_Variant, + &ett_z3950_T_triples, + &ett_z3950_T_triples_item, + &ett_z3950_T_variant_triples_item_value, + &ett_z3950_TaskPackage, + &ett_z3950_PromptObject, + &ett_z3950_Challenge, + &ett_z3950_Challenge_item, + &ett_z3950_T_promptInfo, + &ett_z3950_Response, + &ett_z3950_Response_item, + &ett_z3950_T_promptResponse, + &ett_z3950_PromptId, + &ett_z3950_T_enummeratedPrompt, + &ett_z3950_Encryption, + &ett_z3950_DES_RN_Object, + &ett_z3950_DRNType, + &ett_z3950_KRBObject, + &ett_z3950_KRBRequest, + &ett_z3950_KRBResponse, + &ett_z3950_SearchInfoReport, + &ett_z3950_SearchInfoReport_item, + &ett_z3950_ResultsByDB, + &ett_z3950_ResultsByDB_item, + &ett_z3950_T_databases, + &ett_z3950_QueryExpression, + &ett_z3950_T_queryExpression_term, + +/*--- End of included file: packet-z3950-ettarr.c ---*/ +#line 1138 "./asn1/z3950/packet-z3950-template.c" + }; + + module_t *z3950_module; + +/* Expert info */ + static ei_register_info ei[] = { +/* Z39.50 expert info */ + +/* MARC expert info */ + { &ei_marc_invalid_length, { "marc.invalid_length", PI_MALFORMED, PI_ERROR, + "MARC record too short", EXPFILL }}, + { &ei_marc_invalid_value, { "marc.invalid_value", PI_MALFORMED, PI_ERROR, + "MARC field has invalid value", EXPFILL }}, + { &ei_marc_invalid_record_length, { "marc.invalid_record_length", PI_MALFORMED, PI_ERROR, + "MARC length field has invalid value", EXPFILL }}, + }; + + expert_module_t* expert_z3950; + + + /* Register protocol */ + proto_z3950 = proto_register_protocol(PNAME, PSNAME, PFNAME); + /* Register fields and subtrees */ + proto_register_field_array(proto_z3950, hf, array_length(hf)); + proto_register_subtree_array(ett, array_length(ett)); + expert_z3950 = expert_register_protocol(proto_z3950); + expert_register_field_array(expert_z3950, ei, array_length(ei)); + + /* Register preferences */ + z3950_module = prefs_register_protocol(proto_z3950, NULL); + prefs_register_bool_preference(z3950_module, "desegment_buffers", + "Reassemble Z39.50 buffers spanning multiple TCP segments", + "Whether the Z39.50 dissector should reassemble TDS buffers spanning multiple TCP segments. " + "To use this option, you must also enable \"Allow subdissectors to reassemble TCP streams\" in the TCP protocol settings.", + &z3950_desegment); + + /* Allow dissector to be found by name. */ + z3950_handle = register_dissector(PSNAME, dissect_z3950_segment, + proto_z3950); + +} + +/*--- proto_reg_handoff_z3950 ---------------------------------------*/ +void +proto_reg_handoff_z3950(void) +{ + + dissector_add_uint_with_preference("tcp.port", + global_z3950_port, z3950_handle); + + +/*--- Included file: packet-z3950-dis-tab.c ---*/ +#line 1 "./asn1/z3950/packet-z3950-dis-tab.c" + register_ber_oid_dissector("1.2.840.10003.5.100", dissect_Explain_Record_PDU, proto_z3950, "Explain-record"); + register_ber_oid_dissector("1.2.840.10003.5.101", dissect_SutrsRecord_PDU, proto_z3950, "Sutrs-record"); + register_ber_oid_dissector("1.2.840.10003.5.102", dissect_OPACRecord_PDU, proto_z3950, "OPAC-record"); + register_ber_oid_dissector("1.2.840.10003.5.103", dissect_BriefBib_PDU, proto_z3950, "Summary-record"); + register_ber_oid_dissector("1.2.840.10003.5.105", dissect_GenericRecord_PDU, proto_z3950, "GRS-1-record"); + register_ber_oid_dissector("1.2.840.10003.5.106", dissect_TaskPackage_PDU, proto_z3950, "ESTaskPackage"); + register_ber_oid_dissector("1.2.840.10003.4.2", dissect_DiagnosticFormat_PDU, proto_z3950, "diag-1"); + register_ber_oid_dissector("1.2.840.10003.8.1", dissect_PromptObject_PDU, proto_z3950, "Prompt-1"); + register_ber_oid_dissector("1.2.840.10003.8.2", dissect_DES_RN_Object_PDU, proto_z3950, "DES-1"); + register_ber_oid_dissector("1.2.840.10003.8.3", dissect_KRBObject_PDU, proto_z3950, "KRB-1"); + register_ber_oid_dissector("1.2.840.10003.10.1", dissect_SearchInfoReport_PDU, proto_z3950, "SearchResult-1"); + register_ber_oid_dissector("1.2.840.10003.10.1000.17.1", dissect_OCLC_UserInformation_PDU, proto_z3950, "OCLC-UserInfo-1"); + + +/*--- End of included file: packet-z3950-dis-tab.c ---*/ +#line 1189 "./asn1/z3950/packet-z3950-template.c" + + register_ber_oid_dissector(Z3950_RECORDSYNTAX_MARC21_OID, dissect_marc_record, proto_z3950, "MARC21"); + + oid_add_from_string("Z39.50", "1.2.840.10003"); + oid_add_from_string("Z39.50-APDU", "1.2.840.10003.2"); + oid_add_from_string("Z39.50-attributeSet", "1.2.840.10003.3"); + oid_add_from_string("Z39.50-diagnostic", "1.2.840.10003.4"); + oid_add_from_string("Z39.50-recordSyntax", "1.2.840.10003.5"); + oid_add_from_string("Z39.50-resourceReport", "1.2.840.10003.7"); + oid_add_from_string("Z39.50-accessControl", "1.2.840.10003.8"); + oid_add_from_string("Z39.50-extendedService", "1.2.840.10003.9"); + oid_add_from_string("Z39.50-userinfoFormat", "1.2.840.10003.10"); + oid_add_from_string("Z39.50-elementSpec", "1.2.840.10003.11"); + oid_add_from_string("Z39.50-variantSet", "1.2.840.10003.12"); + oid_add_from_string("Z39.50-schema", "1.2.840.10003.13"); + oid_add_from_string("Z39.50-tagSet", "1.2.840.10003.14"); + oid_add_from_string("Z39.50-negotiation", "1.2.840.10003.15"); + oid_add_from_string("Z39.50-query", "1.2.840.10003.16"); + /* MARC Record Syntaxes */ + oid_add_from_string("UNIMARC","1.2.840.10003.5.1"); + oid_add_from_string("INTERMARC","1.2.840.10003.5.2"); + oid_add_from_string("CCF","1.2.840.10003.5.3"); + oid_add_from_string("MARC21 (formerly USMARC)",Z3950_RECORDSYNTAX_MARC21_OID); + oid_add_from_string("UKMARC","1.2.840.10003.5.11"); + oid_add_from_string("NORMARC","1.2.840.10003.5.12"); + oid_add_from_string("Librismarc","1.2.840.10003.5.13"); + oid_add_from_string("danMARC2","1.2.840.10003.5.14"); + oid_add_from_string("Finmarc","1.2.840.10003.5.15"); + oid_add_from_string("MAB","1.2.840.10003.5.16"); + oid_add_from_string("Canmarc","1.2.840.10003.5.17"); + oid_add_from_string("SBN","1.2.840.10003.5.18"); + oid_add_from_string("Picamarc","1.2.840.10003.5.19"); + oid_add_from_string("Ausmarc","1.2.840.10003.5.20"); + oid_add_from_string("Ibermarc","1.2.840.10003.5.21"); + oid_add_from_string("Catmarc","1.2.840.10003.5.22"); + oid_add_from_string("Malmarc","1.2.840.10003.5.23"); + oid_add_from_string("JPmarc","1.2.840.10003.5.24"); + oid_add_from_string("SWEMarc","1.2.840.10003.5.25"); + oid_add_from_string("SIGLEmarc","1.2.840.10003.5.26"); + oid_add_from_string("ISDS/ISSNmarc","1.2.840.10003.5.27"); + oid_add_from_string("RUSMarc","1.2.840.10003.5.28"); + oid_add_from_string("Hunmarc","1.2.840.10003.5.29"); + oid_add_from_string("NACSIS-CATP","1.2.840.10003.5.30"); + oid_add_from_string("FINMARC2000","1.2.840.10003.5.31"); + oid_add_from_string("MARC21-fin","1.2.840.10003.5.32"); + oid_add_from_string("COMARC","1.2.840.10003.5.33"); + /* Non-MARC record syntaxes */ + oid_add_from_string("Explain","1.2.840.10003.5.100"); + oid_add_from_string("Explain with ZSQL","1.2.840.10003.5.100.1"); + oid_add_from_string("SUTRS","1.2.840.10003.5.101"); + oid_add_from_string("OPAC","1.2.840.10003.5.102"); + oid_add_from_string("Summary","1.2.840.10003.5.103"); + oid_add_from_string("GRS-0","1.2.840.10003.5.104"); + oid_add_from_string("GRS-1","1.2.840.10003.5.105"); + oid_add_from_string("ESTaskPackage","1.2.840.10003.5.106"); + oid_add_from_string("fragment","1.2.840.10003.5.108"); + /* Attribute sets */ + oid_add_from_string("bib-1",Z3950_ATSET_BIB1_OID); + oid_add_from_string("exp-1","1.2.840.10003.3.2"); + oid_add_from_string("ext-1","1.2.840.10003.3.3"); + oid_add_from_string("ccl-1","1.2.840.10003.3.4"); + oid_add_from_string("gils","1.2.840.10003.3.5"); + oid_add_from_string("stas","1.2.840.10003.3.6"); + oid_add_from_string("collections-1","1.2.840.10003.3.7"); + oid_add_from_string("cimi-1","1.2.840.10003.3.8"); + oid_add_from_string("geo-1","1.2.840.10003.3.9"); + oid_add_from_string("ZBIG","1.2.840.10003.3.10"); + oid_add_from_string("util","1.2.840.10003.3.11"); + oid_add_from_string("xd-1","1.2.840.10003.3.12"); + oid_add_from_string("Zthes","1.2.840.10003.3.13"); + oid_add_from_string("Fin-1","1.2.840.10003.3.14"); + oid_add_from_string("Dan-1","1.2.840.10003.3.15"); + oid_add_from_string("Holdings","1.2.840.10003.3.16"); + oid_add_from_string("MARC","1.2.840.10003.3.17"); + oid_add_from_string("bib-2","1.2.840.10003.3.18"); + oid_add_from_string("ZeeRex","1.2.840.10003.3.19"); + /* Diagnostic sets */ + oid_add_from_string("bib-1-diagnostics",Z3950_DIAGSET_BIB1_OID); + +} + +/* MARC routines */ + +static int +dissect_marc_record(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void * data _U_) +{ + proto_item *record_item, *leader_item, + *directory_item, + *fields_item, + *item; + proto_tree *marc_tree, *leader_tree, + *directory_tree, + *fields_tree; + marc_directory_entry *marc_directory; + guint len = tvb_reported_length(tvb); + const guint8 *marc_value_str; + guint record_length = 0, + data_offset = 0, + length_of_field_size, + starting_character_position_size, + directory_entry_len, + directory_entry_count, + dir_index, + offset = 0; + guint32 marc_value_char; + + record_item = proto_tree_add_item(tree, hf_marc_record, + tvb, 0, len, ENC_NA); + marc_tree = proto_item_add_subtree(record_item, ett_marc_record); + if (len < MARC_LEADER_LENGTH) { + expert_add_info_format(pinfo, record_item, + &ei_marc_invalid_record_length, + "MARC record length %d is shorter than leader", len); + } + leader_item = proto_tree_add_item(marc_tree, hf_marc_leader, tvb, 0, + MARC_LEADER_LENGTH, ENC_NA); + leader_tree = proto_item_add_subtree(leader_item, ett_marc_leader); + + marc_value_str = NULL; + item = proto_tree_add_item_ret_string(leader_tree, + hf_marc_leader_length, tvb, offset, 5, ENC_ASCII|ENC_NA, + wmem_packet_scope(),&marc_value_str); + offset += 5; + + if (marc_value_str) { + if (isdigit_string(marc_value_str)) { + record_length = (guint)strtoul(marc_value_str, NULL, 10); + } + else { + expert_add_info_format(pinfo, item, + &ei_marc_invalid_value, + "MARC length field '%s' contains invalid characters", + marc_value_str ); + } + if (record_length != len) { + expert_add_info_format(pinfo, item, + &ei_marc_invalid_length, + "MARC length field value %d does not match reported length %d", + record_length, len); + } + } + + proto_tree_add_item(leader_tree, hf_marc_leader_status, tvb, offset, 1, ENC_ASCII); + offset += 1; + proto_tree_add_item(leader_tree, hf_marc_leader_type, tvb, offset, 1, ENC_ASCII); + offset += 1; + proto_tree_add_item(leader_tree, hf_marc_leader_biblevel, tvb, offset, 1, ENC_ASCII); + offset += 1; + proto_tree_add_item(leader_tree, hf_marc_leader_control, tvb, offset, 1, ENC_ASCII); + offset += 1; + proto_tree_add_item(leader_tree, hf_marc_leader_encoding, tvb, offset, 1, ENC_ASCII); + offset += 1; + marc_value_char = MARC_CHAR_UNINITIALIZED; + item = proto_tree_add_item_ret_uint(leader_tree, hf_marc_leader_indicator_count, + tvb, offset, 1, ENC_ASCII, &marc_value_char); + offset += 1; + if (marc_value_char != MARC_CHAR_UNINITIALIZED) { + if (!marc_isdigit(marc_value_char)) { + expert_add_info_format(pinfo, item, &ei_marc_invalid_value, + "Indicator count '%c' is invalid", marc_value_char); + } + else { + if (marc_char_to_int(marc_value_char) != 2) { + expert_add_info_format(pinfo, item, &ei_marc_invalid_length, + "MARC21 requires indicator count equal 2, not %d", + marc_char_to_int(marc_value_char)); + } + } + } + + marc_value_char = MARC_CHAR_UNINITIALIZED; + item = proto_tree_add_item_ret_uint(leader_tree, hf_marc_leader_subfield_count, + tvb, offset, 1, ENC_ASCII, &marc_value_char); + offset += 1; + if (marc_value_char != MARC_CHAR_UNINITIALIZED) { + if (!marc_isdigit(marc_value_char)) { + expert_add_info_format(pinfo, item, &ei_marc_invalid_value, + "Subfield count '%c' is invalid", marc_value_char); + } + else { + if (marc_char_to_int(marc_value_char) != 2) { + expert_add_info_format(pinfo, item, &ei_marc_invalid_length, + "MARC21 requires subfield count equal 2, not %d", + marc_char_to_int(marc_value_char)); + } + } + } + + item = proto_tree_add_item_ret_string(leader_tree, hf_marc_leader_data_offset, + tvb, offset, 5, ENC_ASCII|ENC_NA, + wmem_packet_scope(),&marc_value_str); + offset += 5; + if (marc_value_str) { + if (isdigit_string(marc_value_str)) { + data_offset = (guint)strtoul(marc_value_str, NULL, 10); + } + else { + expert_add_info_format(pinfo, item, + &ei_marc_invalid_value, + "MARC data offset field '%s' contains invalid characters", + marc_value_str ); + } + if (data_offset < MARC_LEADER_LENGTH || + data_offset > record_length) { + expert_add_info_format(pinfo, item, + &ei_marc_invalid_length, + "MARC data offset %d does not lie within record (length %d)", + data_offset, len); + } + } + proto_tree_add_item(leader_tree, hf_marc_leader_encoding_level, tvb, offset, 1, ENC_ASCII); + offset += 1; + proto_tree_add_item(leader_tree, hf_marc_leader_descriptive_cataloging, tvb, offset, 1, ENC_ASCII); + offset += 1; + proto_tree_add_item(leader_tree, hf_marc_leader_multipart_level, tvb, offset, 1, ENC_ASCII); + offset += 1; + marc_value_char = MARC_CHAR_UNINITIALIZED; + item = proto_tree_add_item_ret_uint(leader_tree, hf_marc_leader_length_of_field_length, + tvb, offset, 1, ENC_ASCII, &marc_value_char); + offset += 1; + length_of_field_size = 4; + if (marc_value_char != MARC_CHAR_UNINITIALIZED) { + if (!marc_isdigit(marc_value_char)) { + expert_add_info_format(pinfo, item, &ei_marc_invalid_value, + "Length-of field-length '%c' is invalid", marc_value_char); + } + else { + if (marc_char_to_int(marc_value_char) != 4) { + expert_add_info_format(pinfo, item, &ei_marc_invalid_length, + "MARC21 requires length-of-field equal 4, not %d", + marc_char_to_int(marc_value_char)); + } + } + } + + marc_value_char = MARC_CHAR_UNINITIALIZED; + item = proto_tree_add_item_ret_uint(leader_tree, hf_marc_leader_starting_character_position_length, + tvb, offset, 1, ENC_ASCII, &marc_value_char); + offset += 1; + starting_character_position_size = 5; + if (marc_value_char != MARC_CHAR_UNINITIALIZED) { + if (!marc_isdigit(marc_value_char)) { + expert_add_info_format(pinfo, item, &ei_marc_invalid_value, + "Starting-character-position length '%c' is invalid", marc_value_char); + } + else { + if (marc_char_to_int(marc_value_char) != 5) { + expert_add_info_format(pinfo, item, &ei_marc_invalid_length, + "MARC21 requires starting-character-position equal 5, not %d", + marc_char_to_int(marc_value_char)); + } + } + } + + proto_tree_add_item(leader_tree, hf_marc_leader_implementation_defined_length, tvb, offset, 1, ENC_ASCII); + offset += 1; + + /* One position is defined as unused-must-be-zero. + * Don't bother displaying or checking it. */ + offset += 1; + + /* Process the directory */ + + directory_entry_len = 3 + length_of_field_size + + starting_character_position_size; + directory_entry_count = ((data_offset - 1) - MARC_LEADER_LENGTH) / directory_entry_len; + + marc_directory = (marc_directory_entry *)wmem_alloc0(wmem_packet_scope(), + directory_entry_count * sizeof(marc_directory_entry)); + + directory_item = proto_tree_add_item(marc_tree, hf_marc_directory, + tvb, offset, data_offset - offset, ENC_NA); + directory_tree = proto_item_add_subtree(directory_item, ett_marc_directory); + + dir_index = 0; + /* Minus one for the terminator character */ + while (offset < (data_offset - 1)) { + guint32 tag_value = 0, + length_value = 0, + starting_char_value = 0; + proto_item *length_item; + proto_item *directory_entry_item; + proto_tree *directory_entry_tree; + + directory_entry_item = proto_tree_add_item(directory_tree, hf_marc_directory_entry, + tvb, offset, directory_entry_len, ENC_NA); + directory_entry_tree = proto_item_add_subtree(directory_entry_item, ett_marc_directory_entry); + + marc_value_str = NULL; + item = proto_tree_add_item_ret_string(directory_entry_tree, hf_marc_directory_entry_tag, + tvb, offset, 3, ENC_ASCII, + wmem_packet_scope(), &marc_value_str); + offset += 3; + if (marc_value_str) { + if (isdigit_string(marc_value_str)) { + tag_value = (guint)strtoul(marc_value_str, NULL, 10); + } + else { + expert_add_info_format(pinfo, item, + &ei_marc_invalid_value, + "MARC directory tag value %d ('%s') contains invalid characters", + dir_index, marc_value_str ); + } + } + marc_value_str = NULL; + length_item = proto_tree_add_item_ret_string(directory_entry_tree, + hf_marc_directory_entry_length, + tvb, offset, length_of_field_size, ENC_ASCII, + wmem_packet_scope(), &marc_value_str); + offset += length_of_field_size; + if (marc_value_str) { + if (isdigit_string(marc_value_str)) { + length_value = (guint)strtoul(marc_value_str, NULL, 10); + } + else { + expert_add_info_format(pinfo, length_item, + &ei_marc_invalid_value, + "MARC directory length value %d ('%s') contains invalid characters", + dir_index, marc_value_str ); + } + } + marc_value_str = NULL; + item = proto_tree_add_item_ret_string(directory_entry_tree, hf_marc_directory_entry_starting_position, + tvb, offset, starting_character_position_size, ENC_ASCII, + wmem_packet_scope(), &marc_value_str); + offset += starting_character_position_size; + if (marc_value_str) { + if (isdigit_string(marc_value_str)) { + starting_char_value = (guint)strtoul(marc_value_str, NULL, 10); + } + else { + expert_add_info_format(pinfo, item, + &ei_marc_invalid_value, + "MARC directory entry %d starting char value '%s' contains invalid characters", + dir_index, marc_value_str ); + } + } + + if (starting_char_value >= (record_length - data_offset)) { + expert_add_info_format(pinfo, item, + &ei_marc_invalid_value, + "MARC directory entry %d starting char value %d is outside record size %d", + dir_index, starting_char_value, (record_length - data_offset)); + } + if ((starting_char_value + length_value) >= (record_length - data_offset)) { + expert_add_info_format(pinfo, length_item, + &ei_marc_invalid_value, + "MARC directory entry %d length value %d goes outside record size %d", + dir_index, length_value, (record_length - data_offset)); + } + marc_directory[dir_index].tag = tag_value; + marc_directory[dir_index].length = length_value; + marc_directory[dir_index].starting_character = starting_char_value; + dir_index++; + } + proto_tree_add_item(directory_tree, hf_marc_directory_terminator, + tvb, offset, 1, ENC_ASCII); + offset += 1; + + fields_item = proto_tree_add_item(marc_tree, hf_marc_fields, + tvb, offset, record_length - offset, ENC_NA); + fields_tree = proto_item_add_subtree(fields_item, ett_marc_fields); + + for (dir_index = 0; dir_index < directory_entry_count; dir_index++) { + const gchar *tag_str; + proto_item *field_item; + proto_tree *field_tree; + + field_item = proto_tree_add_item(fields_tree, hf_marc_field, + tvb, offset, marc_directory[dir_index].length, ENC_NA); + field_tree = proto_item_add_subtree(field_item, ett_marc_field); + + tag_str = try_val_to_str(marc_directory[dir_index].tag, marc_tag_names); + if (tag_str) { + proto_item_append_text(field_item," Tag %03d (%s)", + marc_directory[dir_index].tag, tag_str); + } + else { + proto_item_append_text(field_item," Tag %03d", + marc_directory[dir_index].tag); + } + + if (marc_directory[dir_index].tag < 10) { + proto_tree_add_item(field_tree, hf_marc_field_control, + tvb, offset, marc_directory[dir_index].length - 1, ENC_ASCII|ENC_NA); + offset += marc_directory[dir_index].length - 1; + proto_tree_add_item(field_tree, hf_marc_field_terminator, + tvb, offset, 1, ENC_ASCII); + offset += 1; + } + else { + guint next_offset = offset + marc_directory[dir_index].length - 1; + proto_tree_add_item(field_tree, hf_marc_field_indicator1, + tvb, offset, 1, ENC_ASCII); + offset += 1; + proto_tree_add_item(field_tree, hf_marc_field_indicator2, + tvb, offset, 1, ENC_ASCII); + offset += 1; + do { + gint next_subfield; + proto_tree_add_item(field_tree, hf_marc_field_subfield_indicator, + tvb, offset, 1, ENC_ASCII); + offset += 1; + proto_tree_add_item(field_tree, hf_marc_field_subfield_tag, + tvb, offset, 1, ENC_ASCII); + offset += 1; + next_subfield = tvb_find_guint8(tvb, offset, next_offset - offset, + MARC_SUBFIELD_INDICATOR); + if (next_subfield >= 0) { + proto_tree_add_item(field_tree, hf_marc_field_subfield, + tvb, offset, next_subfield - offset, ENC_ASCII|ENC_NA); + offset += (next_subfield - offset); + } + else { + proto_tree_add_item(field_tree, hf_marc_field_subfield, + tvb, offset, next_offset - offset, ENC_ASCII|ENC_NA); + offset = next_offset; + } + } while (offset < next_offset); + proto_tree_add_item(field_tree, hf_marc_field_terminator, + tvb, offset, 1, ENC_ASCII); + offset += 1; + } + + } + proto_tree_add_item(marc_tree, hf_marc_record_terminator, + tvb, offset, 1, ENC_ASCII); + offset += 1; + + if (offset != len) { + expert_add_info_format(pinfo, record_item, + &ei_marc_invalid_record_length, + "MARC record component length %d does not match record length %d", + offset, len); + } + + return len; +} + +/* + * Editor modelines + * + * Local Variables: + * c-basic-offset: 4 + * tab-width: 8 + * indent-tabs-mode: nil + * End: + * + * ex: set shiftwidth=4 tabstop=8 expandtab: + * :indentSize=4:tabSize=8:noTabs=true: + */ diff --git a/epan/dissectors/packet-z3950.h b/epan/dissectors/packet-z3950.h new file mode 100644 index 0000000000..6bbf74d6f8 --- /dev/null +++ b/epan/dissectors/packet-z3950.h @@ -0,0 +1,24 @@ +/* Do not modify this file. Changes will be overwritten. */ +/* Generated automatically by the ASN.1 to Wireshark dissector compiler */ +/* packet-z3950.h */ +/* asn2wrs.py -b -p z3950 -c ./z3950.cnf -s ./packet-z3950-template -D . -O ../.. z3950.asn z3950-oclc.asn z3950-externals.asn */ + +/* Input file: packet-z3950-template.h */ + +#line 1 "./asn1/z3950/packet-z3950-template.h" +/* packet-z3950.h + * Routines for foo packet dissection + * + * + * Wireshark - Network traffic analyzer + * By Gerald Combs <gerald@wireshark.org> + * Copyright 1998 Gerald Combs + * + * SPDX-License-Identifier: GPL-2.0-or-later + */ + +#ifndef PACKET_Z3950_H +#define PACKET_Z3950_H + + +#endif /* PACKET_Z3950_H */ diff --git a/wsutil/str_util.c b/wsutil/str_util.c index eb76412a50..cb5dac6e78 100644 --- a/wsutil/str_util.c +++ b/wsutil/str_util.c @@ -101,7 +101,7 @@ isprint_utf8_string(const gchar *str, guint length) /* Check if an entire string is digits. */ gboolean -isdigit_string(guchar *str) +isdigit_string(const guchar *str) { guint pos; diff --git a/wsutil/str_util.h b/wsutil/str_util.h index 5e259833a9..dc1aa2c656 100644 --- a/wsutil/str_util.h +++ b/wsutil/str_util.h @@ -77,7 +77,7 @@ gboolean isprint_utf8_string(const gchar *string, guint length); * @return TRUE if the entire string is digits, otherwise FALSE */ WS_DLL_PUBLIC -gboolean isdigit_string(guchar *string); +gboolean isdigit_string(const guchar *string); WS_DLL_PUBLIC int ws_xton(char ch); |