diff options
| author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-10 20:34:10 +0000 |
|---|---|---|
| committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-10 20:34:10 +0000 |
| commit | e4ba6dbc3f1e76890b22773807ea37fe8fa2b1bc (patch) | |
| tree | 68cb5ef9081156392f1dd62a00c6ccc1451b93df /epan/dissectors/asn1/z3950/z3950-externals.asn | |
| parent | Initial commit. (diff) | |
| download | wireshark-e4ba6dbc3f1e76890b22773807ea37fe8fa2b1bc.tar.xz wireshark-e4ba6dbc3f1e76890b22773807ea37fe8fa2b1bc.zip | |
Adding upstream version 4.2.2.upstream/4.2.2
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'epan/dissectors/asn1/z3950/z3950-externals.asn')
| -rw-r--r-- | epan/dissectors/asn1/z3950/z3950-externals.asn | 1679 |
1 files changed, 1679 insertions, 0 deletions
diff --git a/epan/dissectors/asn1/z3950/z3950-externals.asn b/epan/dissectors/asn1/z3950/z3950-externals.asn new file mode 100644 index 00000000..4ce96836 --- /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 |