path: root/lib/asn1/test/asn1_SUITE_data/rfcs/DirectoryAbstractService.asn1

-- Module DirectoryAbstractService (X.511:08/1997)
DirectoryAbstractService {joint-iso-itu-t ds(5) module(1)
  directoryAbstractService(2) 3} DEFINITIONS ::=
BEGIN

-- EXPORTS All 
-- The types and values defined in this module are exported for use in the other ASN.1 modules contained 
-- within the Directory Specifications, and for the use of other applications which will use them to access 
-- Directory services. Other applications may use them for their own purposes, but this will not constrain
-- extensions and modifications needed to maintain or improve the Directory service.
IMPORTS
  informationFramework, distributedOperations, authenticationFramework, 
    dap, directoryShadowAbstractService, basicAccessControl, enhancedSecurity,
    id-at
    FROM UsefulDefinitions {joint-iso-itu-t ds(5) module(1)
      usefulDefinitions(0) 3}
  AttributeTypeAndValue
    FROM BasicAccessControl basicAccessControl
  AgreementID
    FROM DirectoryShadowAbstractService directoryShadowAbstractService
  Attribute, AttributeType, AttributeValue, AttributeValueAssertion,
    DistinguishedName, Name, RelativeDistinguishedName, SupportedAttributes,
    ATTRIBUTE, MATCHING-RULE, ContextAssertion, AttributeTypeAssertion,
    OBJECT-CLASS, RelaxationPolicy
    FROM InformationFramework informationFramework
  OperationProgress, ReferenceType, Exclusions, AccessPoint,
    ContinuationReference
    FROM DistributedOperations distributedOperations
  CertificationPath, SIGNED{}, SIGNATURE{}, ENCRYPTED{}, AlgorithmIdentifier,
    AttributeCertificationPath
    FROM AuthenticationFramework authenticationFramework
  OPTIONALLY-PROTECTED{}, OPTIONALLY-PROTECTED-SEQ{}
    FROM EnhancedSecurity enhancedSecurity
  id-opcode-read, id-opcode-compare, id-opcode-abandon, id-opcode-list,
    id-opcode-search, id-opcode-addEntry, id-opcode-removeEntry,
    id-opcode-modifyEntry, id-opcode-modifyDN, id-errcode-abandoned,
    id-errcode-abandonFailed, id-errcode-attributeError, id-errcode-nameError,
    id-errcode-referral, id-errcode-securityError, id-errcode-serviceError,
    id-errcode-updateError
    FROM DirectoryAccessProtocol dap
  OPERATION, ERROR, Code
    FROM Remote-Operations-Information-Objects {joint-iso-itu-t
      remote-operations(4) informationObjects(5) version1(0)}
  emptyUnbind
    FROM Remote-Operations-Useful-Definitions {joint-iso-itu-t
      remote-operations(4) useful-definitions(7) version1(0)}
  InvokeId
    FROM Remote-Operations-Generic-ROS-PDUs {joint-iso-itu-t
      remote-operations(4) generic-ROS-PDUs(6) version1(0)}
  --PROTECTED
  --	FROM Notation { joint-iso-itu-t genericULS (20) modules (1) notation (1) }
  SPKM-REQ, SPKM-REP-TI, SPKM-ERROR
    FROM SpkmGssTokens {iso(1) identified-organization(3) dod(6) internet(1)
      security(5) mechanisms(5) spkm(1) spkmGssTokens(10)};

-- Common data types 
-- Parameterized type for representing optional signing 
OPTIONALLY-SIGNED{Type} ::= CHOICE {unsigned  Type,
                                    signed    SIGNED{Type}
}

CommonArguments ::= SET {
  serviceControls     [30]  ServiceControls DEFAULT {},
  securityParameters  [29]  SecurityParameters OPTIONAL,
  requestor           [28]  DistinguishedName OPTIONAL,
  operationProgress
    [27]  OperationProgress DEFAULT {nameResolutionPhase notStarted},
  aliasedRDNs         [26]  INTEGER OPTIONAL,
  criticalExtensions  [25]  BIT STRING OPTIONAL,
  referenceType       [24]  ReferenceType OPTIONAL,
  entryOnly           [23]  BOOLEAN DEFAULT TRUE,
  nameResolveOnMaste  [21]  BOOLEAN DEFAULT FALSE,
  operationContexts   [20]  ContextSelection OPTIONAL,
  familyGrouping      [19]  FamilyGrouping DEFAULT entryOnly
}

FamilyGrouping ::= ENUMERATED {
  entryOnly(1), compoundEntry(2), strands(3), multiStrand(4)}

CommonResults ::= SET {
  securityParameters  [30]  SecurityParameters OPTIONAL,
  performer           [29]  DistinguishedName OPTIONAL,
  aliasDereferenced   [28]  BOOLEAN DEFAULT FALSE,
  notification        [27]  SEQUENCE SIZE (1..MAX) OF Attribute OPTIONAL
}

CommonResultsSeq ::= SEQUENCE {
  securityParameters  [30]  SecurityParameters OPTIONAL,
  performer           [29]  DistinguishedName OPTIONAL,
  aliasDereferenced   [28]  BOOLEAN DEFAULT FALSE
}

ServiceControls ::= SET {
  options              [0]  ServiceControlOptions DEFAULT {},
  priority             [1]  INTEGER {low(0), medium(1), high(2)} DEFAULT medium,
  timeLimit            [2]  INTEGER OPTIONAL,
  sizeLimit            [3]  INTEGER OPTIONAL,
  scopeOfReferral      [4]  INTEGER {dmd(0), country(1)} OPTIONAL,
  attributeSizeLimit   [5]  INTEGER OPTIONAL,
  manageDSAITPlaneRef
    [6]  SEQUENCE {dsaName      Name,
                   agreementID  AgreementID} OPTIONAL,
  serviceType          [7]  OBJECT IDENTIFIER OPTIONAL,
  userClass            [8]  INTEGER OPTIONAL
}

ServiceControlOptions ::= BIT STRING {
  preferChaining(0), chainingProhibited(1), localScope(2), dontUseCopy(3),
  dontDereferenceAliases(4), subentries(5), copyShallDo(6),
  partialNameResolution(7), manageDSAIT(8), noSubtypeMatch(9),
  noSubtypeSelection(10), countFamily(11)}

EntryInformationSelection ::= SET {
  attributes
    CHOICE {allUserAttributes  [0]  NULL,
            select             [1]  SET OF AttributeType
            --  empty set implies no attributes are requested 
  } DEFAULT allUserAttributes:NULL,
  infoTypes
    [2]  INTEGER {attributeTypesOnly(0), attributeTypesAndValues(1)}
      DEFAULT attributeTypesAndValues,
  extraAttributes
    CHOICE {allOperationalAttributes  [3]  NULL,
            select                    [4]  SET OF AttributeType} OPTIONAL,
  contextSelection  ContextSelection OPTIONAL,
  returnContexts    BOOLEAN DEFAULT FALSE,
  familyReturn      FamilyReturn DEFAULT {memberSelect contributingEntriesOnly}
}

ContextSelection ::= CHOICE {
  allContexts       NULL,
  selectedContexts  SET OF TypeAndContextAssertion
}

TypeAndContextAssertion ::= SEQUENCE {
  type               AttributeType,
  contextAssertions
    CHOICE {preference  SEQUENCE OF ContextAssertion,
            all         SET OF ContextAssertion}
}

FamilyReturn ::= SEQUENCE {
  memberSelect
    ENUMERATED {contributingEntriesOnly(1), participatingEntriesOnly(2),
                compoundEntry(3)},
  familySelect  SEQUENCE SIZE (1..MAX) OF OBJECT-CLASS.&id OPTIONAL
}

family-information ATTRIBUTE ::= {
  WITH SYNTAX  FamilyEntries
  USAGE        directoryOperation
  ID           id-at-family-information
}

FamilyEntries ::= SEQUENCE {
  family-class   OBJECT-CLASS.&id, -- structural object class value
  familyEntries  SEQUENCE OF FamilyEntry
}

FamilyEntry ::= SEQUENCE {
  rdn          RelativeDistinguishedName,
  information
    SEQUENCE OF CHOICE {attributeType  AttributeType,
                        attribute      Attribute},
  family-info  SEQUENCE SIZE (1..MAX) OF FamilyEntries OPTIONAL
}

EntryInformation ::= SEQUENCE {
  name                   Name,
  fromEntry              BOOLEAN DEFAULT TRUE,
  information
    SET SIZE (1..MAX) OF
      CHOICE {attributeType  AttributeType,
              attribute      Attribute} OPTIONAL,
  incompleteEntry        [3]  BOOLEAN DEFAULT FALSE, -- not in 1988-edition systems
  partialNameResolution
    [4]  BOOLEAN DEFAULT FALSE -- not in 1988 or 1993 edition systems --
}

Filter ::= CHOICE {
  item  [0]  FilterItem,
  and   [1]  SET OF Filter,
  or    [2]  SET OF Filter,
  not   [3]  Filter
}

FilterItem ::= CHOICE {
  equality          [0]  AttributeValueAssertion,
  substrings
    [1]  SEQUENCE {type     ATTRIBUTE.&id({SupportedAttributes}),
                   strings
                     SEQUENCE OF
                       CHOICE {initial
                                 [0]  ATTRIBUTE.&Type
                                        ({SupportedAttributes}
                                           {@substrings.type}),
                               any
                                 [1]  ATTRIBUTE.&Type
                                        ({SupportedAttributes}
                                           {@substrings.type}),
                               final
                                 [2]  ATTRIBUTE.&Type
                                        ({SupportedAttributes}
                                           {@substrings.type}),
                               control  Attribute -- Used to specify interpretation of following items
                       }},
  greaterOrEqual    [2]  AttributeValueAssertion,
  lessOrEqual       [3]  AttributeValueAssertion,
  present           [4]  AttributeType,
  approximateMatch  [5]  AttributeValueAssertion,
  extensibleMatch   [6]  MatchingRuleAssertion,
  contextPresent    [7]  AttributeTypeAssertion
}

MatchingRuleAssertion ::= SEQUENCE {
  matchingRule  [1]  SET SIZE (1..MAX) OF MATCHING-RULE.&id,
  type          [2]  AttributeType OPTIONAL,
  matchValue
    [3]  MATCHING-RULE.&AssertionType
           (CONSTRAINED BY {
              -- matchValue must be a value of  type specified by the &AssertionType field of 
              -- one of the MATCHING-RULE information objects identified by matchingRule -- }),
  dnAttributes  [4]  BOOLEAN DEFAULT FALSE
}

PagedResultsRequest ::= CHOICE {
  newRequest
    SEQUENCE {pageSize  INTEGER,
              sortKeys  SEQUENCE SIZE (1..MAX) OF SortKey OPTIONAL,
              reverse   [1]  BOOLEAN DEFAULT FALSE,
              unmerged  [2]  BOOLEAN DEFAULT FALSE},
  queryReference  OCTET STRING
}

SortKey ::= SEQUENCE {
  type          AttributeType,
  orderingRule  MATCHING-RULE.&id OPTIONAL
}

SecurityParameters ::= SET {
  certification-path          [0]  CertificationPath OPTIONAL,
  name                        [1]  DistinguishedName OPTIONAL,
  time                        [2]  Time OPTIONAL,
  random                      [3]  BIT STRING OPTIONAL,
  target                      [4]  ProtectionRequest OPTIONAL,
  response                    [5]  BIT STRING OPTIONAL,
  operationCode               [6]  Code OPTIONAL,
  attributeCertificationPath  [7]  AttributeCertificationPath OPTIONAL,
  errorProtection             [8]  ErrorProtectionRequest OPTIONAL,
  errorCode                   [9]  Code OPTIONAL
}

ProtectionRequest ::= INTEGER {
  none(0), signed(1), encrypted(2), signed-encrypted(3)}

Time ::= CHOICE {utcTime          UTCTime,
                 generalizedTime  GeneralizedTime
}

ErrorProtectionRequest ::= INTEGER {
  none(0), signed(1), encrypted(2), signed-encrypted(3)}

--  Bind and unbind operations 
directoryBind OPERATION ::= {
  ARGUMENT  DirectoryBindArgument
  RESULT    DirectoryBindResult
  ERRORS    {directoryBindError}
}

DirectoryBindArgument ::= SET {
  credentials  [0]  Credentials OPTIONAL,
  versions     [1]  Versions DEFAULT {v1}
}

Credentials ::= CHOICE {
  simple             [0]  SimpleCredentials,
  strong             [1]  StrongCredentials,
  externalProcedure  [2]  EXTERNAL,
  spkm               [3]  SpkmCredentials
}

SimpleCredentials ::= SEQUENCE {
  name      [0]  DistinguishedName,
  validity
    [1]  SET {time1    [0]  CHOICE {utc  UTCTime,
                                    gt   GeneralizedTime} OPTIONAL,
              time2    [1]  CHOICE {utc  UTCTime,
                                    gt   GeneralizedTime} OPTIONAL,
              random1  [2]  BIT STRING OPTIONAL,
              random2  [3]  BIT STRING OPTIONAL},
  password
    [2]  CHOICE {unprotected  OCTET STRING,
                 protected    SIGNATURE{OCTET STRING}} OPTIONAL
}

StrongCredentials ::= SET {
  certification-path          [0]  CertificationPath OPTIONAL,
  bind-token                  [1]  Token,
  name                        [2]  DistinguishedName OPTIONAL,
  attributeCertificationPath  [3]  AttributeCertificationPath OPTIONAL
}

SpkmCredentials ::= CHOICE {req  [0]  SPKM-REQ,
                            rep  [1]  SPKM-REP-TI
}

Token ::=
  SIGNED
    {SEQUENCE {algorithm          [0]  AlgorithmIdentifier,
               name               [1]  DistinguishedName,
               time               [2]  Time,
               random             [3]  BIT STRING,
               response           [4]  BIT STRING OPTIONAL,
               bindIntAlgorithm
                 [5]  SEQUENCE SIZE (1..MAX) OF AlgorithmIdentifier OPTIONAL,
               bindIntKeyInfo     [6]  BindKeyInfo OPTIONAL,
               bindConfAlgorithm
                 [7]  SEQUENCE SIZE (1..MAX) OF AlgorithmIdentifier OPTIONAL,
               bindConfKeyInfo    [8]  BindKeyInfo OPTIONAL}}

Versions ::= BIT STRING {v1(0), v2(1)}

DirectoryBindResult ::= DirectoryBindArgument

directoryBindError ERROR ::= {
  PARAMETER OPTIONALLY-PROTECTED
    {SET {versions  [0]  Versions DEFAULT {v1},
          error
            CHOICE {serviceError   [1]  ServiceProblem,
                    securityError  [2]  SecurityProblem}}}
}

BindKeyInfo ::= ENCRYPTED{BIT STRING}

directoryUnbind OPERATION ::= emptyUnbind

--  Operations, arguments, and results 
read OPERATION ::= {
  ARGUMENT  ReadArgument
  RESULT    ReadResult
  ERRORS
    {attributeError | nameError | serviceError | referral | abandoned |
      securityError}
  CODE      id-opcode-read
}

ReadArgument ::=
  OPTIONALLY-PROTECTED
    {SET {object               [0]  Name,
          selection            [1]  EntryInformationSelection DEFAULT {},
          modifyRightsRequest  [2]  BOOLEAN DEFAULT FALSE,
          COMPONENTS OF CommonArguments}}

ReadResult ::=
  OPTIONALLY-PROTECTED
    {SET {entry         [0]  EntryInformation,
          modifyRights  [1]  ModifyRights OPTIONAL,
          COMPONENTS OF CommonResults}}

ModifyRights ::=
  SET OF
    SEQUENCE {item
                CHOICE {entry      [0]  NULL,
                        attribute  [1]  AttributeType,
                        value      [2]  AttributeValueAssertion},
              permission
                [3]  BIT STRING {add(0), remove(1), rename(2), move(3)}
    }

compare OPERATION ::= {
  ARGUMENT  CompareArgument
  RESULT    CompareResult
  ERRORS
    {attributeError | nameError | serviceError | referral | abandoned |
      securityError}
  CODE      id-opcode-compare
}

CompareArgument ::=
  OPTIONALLY-PROTECTED
    {SET {object     [0]  Name,
          purported  [1]  AttributeValueAssertion,
          COMPONENTS OF CommonArguments}}

CompareResult ::=
  OPTIONALLY-PROTECTED
    {SET {name            Name OPTIONAL,
          matched         [0]  BOOLEAN,
          fromEntry       [1]  BOOLEAN DEFAULT TRUE,
          matchedSubtype  [2]  AttributeType OPTIONAL,
          COMPONENTS OF CommonResults}}

abandon OPERATION ::= {
  ARGUMENT  AbandonArgument
  RESULT    AbandonResult
  ERRORS    {abandonFailed}
  CODE      id-opcode-abandon
}

AbandonArgument ::=
  OPTIONALLY-PROTECTED-SEQ{SEQUENCE {invokeID  [0]  InvokeId}}

AbandonResult ::= CHOICE {
  null         NULL,
  information
    OPTIONALLY-PROTECTED-SEQ{SEQUENCE {invokeID  InvokeId,
                                       COMPONENTS OF CommonResultsSeq
      }}
}

list OPERATION ::= {
  ARGUMENT  ListArgument
  RESULT    ListResult
  ERRORS    {nameError | serviceError | referral | abandoned | securityError}
  CODE      id-opcode-list
}

ListArgument ::=
  OPTIONALLY-PROTECTED
    {SET {object        [0]  Name,
          pagedResults  [1]  PagedResultsRequest OPTIONAL,
          listFamily    [2]  BOOLEAN DEFAULT FALSE,
          COMPONENTS OF CommonArguments}}

ListResult ::=
  OPTIONALLY-PROTECTED
    {CHOICE {listInfo
               SET {name                     Name OPTIONAL,
                    subordinates
                      [1]  SET OF
                             SEQUENCE {rdn         RelativeDistinguishedName,
                                       aliasEntry  [0]  BOOLEAN DEFAULT FALSE,
                                       fromEntry   [1]  BOOLEAN DEFAULT TRUE
                             },
                    partialOutcomeQualifier
                      [2]  PartialOutcomeQualifier OPTIONAL,
                    COMPONENTS OF CommonResults},
             uncorrelatedListInfo  [0]  SET OF ListResult}}

PartialOutcomeQualifier ::= SET {
  limitProblem                   [0]  LimitProblem OPTIONAL,
  unexplored
    [1]  SET SIZE (1..MAX) OF ContinuationReference OPTIONAL,
  unavailableCriticalExtensions  [2]  BOOLEAN DEFAULT FALSE,
  unknownErrors
    [3]  SET SIZE (1..MAX) OF ABSTRACT-SYNTAX.&Type OPTIONAL,
  queryReference                 [4]  OCTET STRING OPTIONAL,
  overspecFilter                 [5]  Filter OPTIONAL,
  notification
    [6]  SEQUENCE SIZE (1..MAX) OF Attribute OPTIONAL,
  entryCount
    CHOICE {bestEstimate  [7]  INTEGER,
            lowEstimate   [8]  INTEGER} OPTIONAL
}

LimitProblem ::= INTEGER {
  timeLimitExceeded(0), sizeLimitExceeded(1), administrativeLimitExceeded(2)
}

search OPERATION ::= {
  ARGUMENT  SearchArgument
  RESULT    SearchResult
  ERRORS
    {attributeError | nameError | serviceError | referral | abandoned |
      securityError}
  CODE      id-opcode-search
}

SearchArgument ::=
  OPTIONALLY-PROTECTED
    {SET {baseObject            [0]  Name,
          subset
            [1]  INTEGER {baseObject(0), oneLevel(1), wholeSubtree(2)}
              DEFAULT baseObject,
          filter                [2]  Filter DEFAULT and:{},
          searchAliases         [3]  BOOLEAN DEFAULT TRUE,
          selection             [4]  EntryInformationSelection DEFAULT {},
          pagedResults          [5]  PagedResultsRequest OPTIONAL,
          matchedValuesOnly     [6]  BOOLEAN DEFAULT FALSE,
          extendedFilter        [7]  Filter OPTIONAL,
          checkOverspecified    [8]  BOOLEAN DEFAULT FALSE,
          relaxation            [9]  RelaxationPolicy OPTIONAL,
          extendedArea          [10]  INTEGER OPTIONAL,
          hierarchySelections   [11]  HierarchySelections DEFAULT {self},
          searchControlOptions
            [12]  SearchControlOptions DEFAULT {searchAliases},
          COMPONENTS OF CommonArguments}}

HierarchySelections ::= BIT STRING {
  self(0), children(1), parent(2), hierarchy(3), top(4), subtree(5),
  siblings(6), siblingChildren(7), siblingSubtree(8), all(9)}

SearchControlOptions ::= BIT STRING {
  searchAliases(0), matchedValuesOnly(1), checkOverspecified(2),
  performExactly(3), includeAllAreas(4), noSystemRelaxation(5), dnAttribute(6),
  matchOnResidualName(7), entryCount(8), useSubset(9),
  separateFamilyMembers(10), searchFamily(11)}

SearchResult ::=
  OPTIONALLY-PROTECTED
    {CHOICE {searchInfo
               SET {name                     Name OPTIONAL,
                    entries                  [0]  SET OF EntryInformation,
                    partialOutcomeQualifier
                      [2]  PartialOutcomeQualifier OPTIONAL,
                    altMatching              [3]  BOOLEAN DEFAULT FALSE,
                    COMPONENTS OF CommonResults},
             uncorrelatedSearchInfo  [0]  SET OF SearchResult}}

addEntry OPERATION ::= {
  ARGUMENT  AddEntryArgument
  RESULT    AddEntryResult
  ERRORS
    {attributeError | nameError | serviceError | referral | securityError |
      updateError}
  CODE      id-opcode-addEntry
}

AddEntryArgument ::=
  OPTIONALLY-PROTECTED
    {SET {object        [0]  Name,
          entry         [1]  SET OF Attribute,
          targetSystem  [2]  AccessPoint OPTIONAL,
          COMPONENTS OF CommonArguments}}

AddEntryResult ::= CHOICE {
  null         NULL,
  information
    OPTIONALLY-PROTECTED-SEQ{SEQUENCE {COMPONENTS OF CommonResultsSeq}}
}

removeEntry OPERATION ::= {
  ARGUMENT  RemoveEntryArgument
  RESULT    RemoveEntryResult
  ERRORS    {nameError | serviceError | referral | securityError | updateError}
  CODE      id-opcode-removeEntry
}

RemoveEntryArgument ::=
  OPTIONALLY-PROTECTED{SET {object  [0]  Name,
                            COMPONENTS OF CommonArguments}}

RemoveEntryResult ::= CHOICE {
  null         NULL,
  information
    OPTIONALLY-PROTECTED-SEQ{SEQUENCE {COMPONENTS OF CommonResultsSeq}}
}

modifyEntry OPERATION ::= {
  ARGUMENT  ModifyEntryArgument
  RESULT    ModifyEntryResult
  ERRORS
    {attributeError | nameError | serviceError | referral | securityError |
      updateError}
  CODE      id-opcode-modifyEntry
}

ModifyEntryArgument ::=
  OPTIONALLY-PROTECTED
    {SET {object     [0]  Name,
          changes    [1]  SEQUENCE OF EntryModification,
          selection  [2]  EntryInformationSelection OPTIONAL,
          COMPONENTS OF CommonArguments}}

ModifyEntryResult ::= CHOICE {
  null         NULL,
  information
    OPTIONALLY-PROTECTED-SEQ{SEQUENCE {entry  [0]  EntryInformation OPTIONAL,
                                       COMPONENTS OF CommonResultsSeq
      }}
}

EntryModification ::= CHOICE {
  addAttribute     [0]  Attribute,
  removeAttribute  [1]  AttributeType,
  addValues        [2]  Attribute,
  removeValues     [3]  Attribute,
  alterValues      [4]  AttributeTypeAndValue,
  resetValue       [5]  AttributeType
}

modifyDN OPERATION ::= {
  ARGUMENT  ModifyDNArgument
  RESULT    ModifyDNResult
  ERRORS    {nameError | serviceError | referral | securityError | updateError}
  CODE      id-opcode-modifyDN
}

ModifyDNArgument ::=
  OPTIONALLY-PROTECTED
    {SET {object        [0]  DistinguishedName,
          newRDN        [1]  RelativeDistinguishedName,
          deleteOldRDN  [2]  BOOLEAN DEFAULT FALSE,
          newSuperior   [3]  DistinguishedName OPTIONAL,
          COMPONENTS OF CommonArguments}}

ModifyDNResult ::= CHOICE {
  null         NULL,
  information
    OPTIONALLY-PROTECTED-SEQ{SEQUENCE {newRDN  RelativeDistinguishedName,
                                       COMPONENTS OF CommonResultsSeq
      }}
}

-- Errors and parameters 
abandoned ERROR ::= { -- not literally an "error"
  PARAMETER OPTIONALLY-PROTECTED  {SET {COMPONENTS OF CommonResults}}
  CODE                            id-errcode-abandoned
}

abandonFailed ERROR ::= {
  PARAMETER OPTIONALLY-PROTECTED
    {SET {problem    [0]  AbandonProblem,
          operation  [1]  InvokeId,
          COMPONENTS OF CommonResults}}
  CODE                            id-errcode-abandonFailed
}

AbandonProblem ::= INTEGER {noSuchOperation(1), tooLate(2), cannotAbandon(3)}

attributeError ERROR ::= {
  PARAMETER OPTIONALLY-PROTECTED
    {SET {object    [0]  Name,
          problems
            [1]  SET OF
                   SEQUENCE {problem  [0]  AttributeProblem,
                             type     [1]  AttributeType,
                             value    [2]  AttributeValue OPTIONAL},
          COMPONENTS OF CommonResults}}
  CODE                            id-errcode-attributeError
}

AttributeProblem ::= INTEGER {
  noSuchAttributeOrValue(1), invalidAttributeSyntax(2),
  undefinedAttributeType(3), inappropriateMatching(4), constraintViolation(5),
  attributeOrValueAlreadyExists(6), contextViolation(7)}

nameError ERROR ::= {
  PARAMETER OPTIONALLY-PROTECTED
    {SET {problem  [0]  NameProblem,
          matched  [1]  Name,
          COMPONENTS OF CommonResults}}
  CODE                            id-errcode-nameError
}

NameProblem ::= INTEGER {
  noSuchObject(1), aliasProblem(2), invalidAttributeSyntax(3),
  aliasDereferencingProblem(4), contextProblem(5)}

referral ERROR ::= { -- not literally an "error"
  PARAMETER OPTIONALLY-PROTECTED
    {SET {candidate  [0]  ContinuationReference,
          COMPONENTS OF CommonResults}}
  CODE                            id-errcode-referral
}

securityError ERROR ::= {
  PARAMETER OPTIONALLY-PROTECTED
    {SET {problem   [0]  SecurityProblem,
          spkmInfo  [1]  SPKM-ERROR,
          COMPONENTS OF CommonResults}}
  CODE                            id-errcode-securityError
}

SecurityProblem ::= INTEGER {
  inappropriateAuthentication(1), invalidCredentials(2),
  insufficientAccessRights(3), invalidSignature(4), protectionRequired(5),
  noInformation(6), blockedCredentials(7), invalidQOPMatch(8), spkmError(9)
}

serviceError ERROR ::= {
  PARAMETER OPTIONALLY-PROTECTED
    {SET {problem  [0]  ServiceProblem,
          COMPONENTS OF CommonResults}}
  CODE                            id-errcode-serviceError
}

ServiceProblem ::= INTEGER {
  busy(1), unavailable(2), unwillingToPerform(3), chainingRequired(4),
  unableToProceed(5), invalidReference(6), timeLimitExceeded(7),
  administrativeLimitExceeded(8), loopDetected(9),
  unavailableCriticalExtension(10), outOfScope(11), ditError(12),
  invalidQueryReference(13), requestedServiceNotAvailable(14),
  relaxationNotSupported(15), unavailableRelaxationLevel(16),
  unsupportedMatchingUse(17), unmatchedKeyAttributes(18),
  ambiguousKeyAttributes(19)}

updateError ERROR ::= {
  PARAMETER OPTIONALLY-PROTECTED
    {SET {problem        [0]  UpdateProblem,
          attributeInfo
            [1]  SET SIZE (1..MAX) OF
                   CHOICE {attributeType  AttributeType,
                           attribute      Attribute} OPTIONAL,
          COMPONENTS OF CommonResults}}
  CODE                            id-errcode-updateError
}

UpdateProblem ::= INTEGER {
  namingViolation(1), objectClassViolation(2), notAllowedOnNonLeaf(3),
  notAllowedOnRDN(4), entryAlreadyExists(5), affectsMultipleDSAs(6),
  objectClassModificationProhibited(7), notAncestor(8), parentNotAncestor(9),
  hierarchyRuleViolation(10), familyRuleViolation(11)}

id-at-family-information OBJECT IDENTIFIER ::= {id-at 64}

END -- DirectoryAbstractService

-- Generated by Asnp, the ASN.1 pretty-printer of France Telecom R&D