aboutsummaryrefslogtreecommitdiffstats
path: root/epan/dissectors
diff options
context:
space:
mode:
authorCraig Jackson <cejackson51@gmail.com>2018-10-24 18:27:24 -0400
committerAnders Broman <a.broman58@gmail.com>2018-12-28 09:28:17 +0000
commit52b7c8929a27376fb9965049054b571369e2ff09 (patch)
treeb940b8d7105f65327cd0179ef12336b7a4092b14 /epan/dissectors
parentc3e22f0ab5b40ff6f08da063e9a9692247597a95 (diff)
Z39.50: Implementation of Z39.50 Information Retrieval protocol
NISO Z39.50 is a protocol used by libraries and library vendors for information retrieval and catalog manipulation. It is defined using ASN.1 using BER encoding. It has an assigned TCP port of 210. This is an initial implementation. Features: - The Z39.50 standard OIDs are defined. - The bib-1 attribute set is decoded. - The bib-1 diagnostics are decoded. - Some OCTET STRINGs which are nearly always printable ASCII are special-cased. - The MARC (MAchine Readable Cataloging) format is decoded. Only the MARC21 variant is currently handled, but this is one of the most common variants. The most common tags are decoded. The MARC dissector is included in the Z39.50 dissector, but the code is structured in such away that it could be pulled out. Todo: - Add information to the Wiki about Z39.50. As part of this work, the definition of isdigit_string() was fixed to avoid const complaints. Change-Id: I29a7db53375ef8be83738a1ab98707761d878717 Reviewed-on: https://code.wireshark.org/review/31209 Petri-Dish: Anders Broman <a.broman58@gmail.com> Tested-by: Petri Dish Buildbot Reviewed-by: Anders Broman <a.broman58@gmail.com>
Diffstat (limited to 'epan/dissectors')
-rw-r--r--epan/dissectors/CMakeLists.txt2
-rw-r--r--epan/dissectors/asn1/CMakeLists.txt1
-rw-r--r--epan/dissectors/asn1/z3950/CMakeLists.txt40
-rw-r--r--epan/dissectors/asn1/z3950/packet-z3950-template.c1639
-rw-r--r--epan/dissectors/asn1/z3950/z3950-externals.asn1679
-rw-r--r--epan/dissectors/asn1/z3950/z3950-oclc.asn14
-rw-r--r--epan/dissectors/asn1/z3950/z3950.asn807
-rw-r--r--epan/dissectors/asn1/z3950/z3950.cnf278
-rw-r--r--epan/dissectors/packet-z3950.c13065
-rw-r--r--epan/dissectors/packet-z3950.h24
10 files changed, 17549 insertions, 0 deletions
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 */
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-25 11:34:45 +0000