From e4ba6dbc3f1e76890b22773807ea37fe8fa2b1bc Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Wed, 10 Apr 2024 22:34:10 +0200 Subject: Adding upstream version 4.2.2. Signed-off-by: Daniel Baumann --- epan/dissectors/asn1/z3950/z3950.asn | 807 +++++++++++++++++++++++++++++++++++ 1 file changed, 807 insertions(+) create mode 100644 epan/dissectors/asn1/z3950/z3950.asn (limited to 'epan/dissectors/asn1/z3950/z3950.asn') diff --git a/epan/dissectors/asn1/z3950/z3950.asn b/epan/dissectors/asn1/z3950/z3950.asn new file mode 100644 index 00000000..e63f46d8 --- /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 -- cgit v1.2.3