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>

1 files changed, 807 insertions, 0 deletions

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