|
DataMuseum.dkPresents historical artifacts from the history of: DKUUG/EUUG Conference tapes |
This is an automatic "excavation" of a thematic subset of
See our Wiki for more about DKUUG/EUUG Conference tapes Excavated with: AutoArchaeologist - Free & Open Source Software. |
top - metrics - downloadIndex: T d
Length: 53989 (0xd2e5)
Types: TextFile
Names: »das-enc.py«
└─⟦3d0c2be1b⟧ Bits:30001254 ISODE-5.0 Tape
└─⟦eba4602b1⟧ »./isode-5.0.tar.Z«
└─⟦d3ac74d73⟧
└─⟦this⟧ »isode-5.0/dsap/x500as/das-enc.py«
-- das-enc.py - manually augmented DirectoryAbstractService module
-- $Header: /f/osi/dsap/x500as/RCS/das-enc.py,v 6.1 89/03/23 22:27:19 mrose Exp $
--
--
-- $Log: das-enc.py,v $
-- Revision 6.1 89/03/23 22:27:19 mrose
-- out-the-door
--
-- Revision 6.0 89/03/18 23:29:21 mrose
-- Release 5.0
--
--
-- NOTICE
--
-- Acquisition, use, and distribution of this module and related
-- materials are subject to the restrictions of a license agreement.
-- Consult the Preface in the User's Manual for the full terms of
-- this agreement.
--
--
DAS
{
joint-iso-ccitt
ds(5)
modules(1)
directoryAbstractService(2)
}
DEFINITIONS ::=
%{
#include "quipu/util.h"
#include "quipu/entry.h"
#include "quipu/common.h"
extern LLog * log_dsap;
%}
PREFIXES encode decode print
BEGIN
-- EXPORTS
-- DirectoryBindArgument ,
-- ReadArgument ,
-- ReadResult ,
-- AbandonArgument ,
-- AbandonResult ,
-- CompareArgument ,
-- CompareResult ,
-- ListArgument ,
-- ListResult ,
-- SearchArgument ,
-- SearchResult ,
-- AddEntryArgument ,
-- AddEntryResult ,
-- RemoveEntryArgument ,
-- RemoveEntryResult ,
-- ModifyEntryArgument ,
-- ModifyEntryResult ,
-- ModifyRDNArgument ,
-- ModifyRDNResult ,
-- AbandonedParm ,
-- AbandonFailedParm ,
-- AttributeErrorParm ,
-- NameErrorParm ,
-- ReferralParm ,
-- SecurityErrorParm ,
-- ServiceErrorParm ,
-- UpdateErrorParm;
IMPORTS
Attribute ,
AttributeType ,
AttributeValue ,
AttributeValueAssertion ,
DistinguishedName ,
Name ,
RelativeDistinguishedName
FROM IF
{
joint-iso-ccitt
ds(5)
modules(1)
informationFramework(1)
}
OperationProgress ,
ContinuationReference ,
InvokeID
FROM DO
{
joint-iso-ccitt
ds(5)
modules(1)
distributedOperations(3)
}
Certificate ,
CertificationPath ,
AlgorithmIdentifier
FROM AF
{
joint-iso-ccitt
ds(5)
modules(1)
authenticationFramework(7)
};
ENCODER encode
SimpleCredentials [[P struct simple_creds *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode SimpleCredentials"));
%}
SEQUENCE
{
name
[0] DistinguishedName [[p parm->usc_dn]]
%{
%} ,
validity
[1] SET
%{
%}
{
time1
[0] UTCTime
%{
%} OPTIONAL <<FALSE>> ,
time2
[1] UTCTime
%{
%} OPTIONAL <<FALSE>> ,
random1
[2] BIT STRING
%{
%} OPTIONAL <<FALSE>> ,
random2
[3] BIT STRING
%{
%} OPTIONAL <<FALSE>>
}
%{
%} OPTIONAL <<FALSE>> ,
password
[2] OCTET STRING [[o parm->usc_passwd $ parm->usc_passwd_len]]
%{
%}
OPTIONAL <<parm->usc_passwd_len != 0>>
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode SimpleCredentials"));
%}
TokenToSign
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At encode TokenToSign"));
%}
SEQUENCE
{
algorithm
[0] AlgorithmIdentifier ,
name
[1] DistinguishedName [[p NULLDN]] ,
time
[2] UTCTime ,
random
[3] BIT STRING
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode TokenToSign"));
%}
Token
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At encode Token"));
%}
SEQUENCE
{
TokenToSign ,
AlgorithmIdentifier ,
BIT STRING
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode Token"));
%}
StrongCredentials
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At encode StrongCredentials"));
%}
SET
{
certificationPath
[0] CertificationPath
OPTIONAL ,
bindToken
[1] Token
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode StrongCredentials"));
%}
Credentials [[P struct simple_creds *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode Credentials"));
%}
CHOICE
<<1>>
{
simple
[0] SimpleCredentials [[p parm]]
%{
%} ,
strong
[1] StrongCredentials ,
externalProcedure
[2] EXTERNAL
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode Credentials"));
%}
Versions [[P int]]
%{
int ver_len = 1;
char *ver_bits = int2strb(parm,ver_len);
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode Versions"));
%}
BIT STRING [[x ver_bits $ ver_len]]
{
v1988(0)
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode Versions"));
%}
SecurityProblem [[P int]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode SecurityProblem"));
%}
INTEGER [[i parm]]
{
inappropriateAuthentication(1) ,
invalidCredentials(2) ,
insufficientAccessRights(3) ,
invalidSignature(4) ,
protectionRequired(5) ,
noInformation(6)
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode SecurityProblem"));
%}
ServiceProblem [[P int]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode ServiceProblem"));
%}
INTEGER [[i parm]]
{
busy(1) ,
unavailable(2) ,
unwillingToPerform(3) ,
chainingRequired(4) ,
unableToProceed(5) ,
invalidReference(6) ,
timeLimitExceeded(7) ,
administrativeLimitExceeded(8) ,
loopDetected(9) ,
unavailableCriticalExtension(10) ,
outOfScope(11) ,
ditError(12)
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode ServiceProblem"));
%}
EntryInformationSelection [[P struct entryinfoselection *]]
%{
Attr_Sequence attr_temp;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode EntryInformationSelection PE"));
%}
SET
{
attributeTypes
CHOICE
<<(parm->eis_allattributes ? 1 : 2)>>
{
allAttributes
[0] NULL ,
select
[1] SET OF
%{
%}
<<attr_temp=parm->eis_select;attr_temp!=NULLATTR;attr_temp=attr_temp->attr_link>>
AttributeType [[p attr_temp->attr_type]]
%{
%}
%{
%}
}
%{
%}
-- DEFAULT allAttributes NULL <<parm->eis_allattributes != TRUE>> ,
OPTIONAL <<parm->eis_allattributes != TRUE>> ,
infoTypes
[2] INTEGER [[i parm->eis_infotypes]]
{
attributeTypesOnly(0) ,
attributeTypesAndValues(1)
}
%{
%}
-- DEFAULT attributeTypesAndValues <<parm->eis_infotypes != EIS_ATTRIBUTESANDVALUES>>
OPTIONAL <<parm->eis_infotypes != EIS_ATTRIBUTESANDVALUES>>
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode EntryInformationSelection PE"));
%}
ServiceControls [[P struct svccontrol *]]
%{
int opt_len = 5;
char *opt_bits;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode ServiceControls PE"));
opt_bits = int2strb(parm->svc_options,opt_len);
%}
SET
{
options
[0] BIT STRING [[x opt_bits $ opt_len]]
{
preferChaining(0) ,
chainingProhibited(1) ,
localScope(2) ,
dontUseCopy(3) ,
dontDereferenceAliases(4)
}
%{
%}
-- DEFAULT {} <<parm->svc_options != 0>> ,
OPTIONAL <<parm->svc_options != 0>> ,
priority
[1] INTEGER [[i parm->svc_prio]]
{
low(0) ,
medium(1) ,
high(2)
}
%{
%}
-- DEFAULT medium <<parm->svc_prio != SVC_PRIO_MED>> ,
OPTIONAL <<parm->svc_prio != SVC_PRIO_MED>> ,
timeLimit
[2] INTEGER [[i parm->svc_timelimit]]
%{
%}
OPTIONAL <<parm->svc_timelimit != SVC_NOTIMELIMIT>> ,
sizeLimit
[3] INTEGER [[i parm->svc_sizelimit]]
%{
%}
OPTIONAL <<parm->svc_sizelimit != SVC_NOSIZELIMIT>> ,
scopeOfReferral
[4] INTEGER [[i parm->svc_scopeofreferral]]
{
dmd(0) ,
country(1)
}
OPTIONAL <<parm->svc_scopeofreferral != SVC_REFSCOPE_NONE>>
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode ServiceControls PE"));
%}
ProtectionRequest
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At encode ProtectionRequest"));
%}
INTEGER
{
none (0) ,
signed (1)
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode ProtectionRequest"));
%}
SecurityParameters
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At encode SecurityParameters"));
%}
SET
{
certificationPath
[0] CertificationPath
OPTIONAL <<FALSE>> ,
name
[1] DistinguishedName [[p NULLDN]]
OPTIONAL <<FALSE>> ,
time
[2] UTCTime
OPTIONAL <<FALSE>> ,
random
[3] BIT STRING
OPTIONAL <<FALSE>> ,
target
[4] ProtectionRequest
OPTIONAL <<FALSE>>
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode SecurityParameters"));
%}
Extension [[P struct extension *]]
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At encode Extension"));
%}
SET
{
identifier
[0] INTEGER [[i parm->ext_id]] ,
critical
[1] BOOLEAN [[b parm->ext_critical]]
-- DEFAULT FALSE ,
OPTIONAL <<parm->ext_critical != FALSE>> ,
item
[2] ANY DEFINED BY identifier [[a parm->ext_item]]
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode Extension"));
%}
EntryInformation [[P struct entrystruct *]]
%{
Attr_Sequence attr_temp;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode EntryInformation PE"));
%}
SEQUENCE
{
DistinguishedName [[p parm->ent_dn]]
%{
%} ,
fromEntry
BOOLEAN [[b parm->ent_iscopy]]
%{
%}
-- DEFAULT TRUE <<parm->ent_iscopy != INFO_COPY>> ,
OPTIONAL <<parm->ent_iscopy != INFO_COPY>> ,
SET OF
%{
%}
<<attr_temp=parm->ent_attr;attr_temp!=NULLATTR;attr_temp=attr_temp->attr_link>>
CHOICE
<<((attr_temp->attr_value == NULLAV) ? 1 : 2)>>
{
AttributeType [[p attr_temp->attr_type]]
%{
%} ,
Attribute [[p attr_temp]]
%{
%}
}
%{
%}
%{
%}
OPTIONAL <<parm->ent_attr != NULLATTR>>
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode EntryInformation PE"));
%}
LimitProblem [[P int]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode LimitProblem PE"));
%}
INTEGER [[i parm]]
{
timeLimitExceeded(0) ,
sizeLimitExceeded(1) ,
administrativeLimitExceeded(2)
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode LimitProblem PE"));
%}
PartialOutcomeQualifier [[P struct part_outcome *]]
%{
ContinuationRef crefp;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode PartialOutcomeQualifier PE"));
%}
SET
{
limitProblem
[0] LimitProblem [[p parm->poq_limitproblem]]
%{
%}
OPTIONAL <<parm->poq_limitproblem != LSR_NOLIMITPROBLEM>> ,
unexplored
[1] SET OF
%{
%}
<<crefp=parm->poq_cref;crefp!=NULLCONTINUATIONREF;crefp=crefp->cr_next>>
ContinuationReference [[p crefp]]
%{
%}
%{
%}
OPTIONAL <<parm->poq_cref != NULLCONTINUATIONREF>> ,
unavailableCriticalExtensions
[2] BOOLEAN
-- DEFAULT FALSE <<FALSE>>
OPTIONAL <<FALSE>>
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode PartialOutcomeQualifier PE"));
%}
FilterItem [[P struct filter_item *]]
%{
int subs_type;
AV_Sequence avs_temp;
Filter_Substrings *subs_temp;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode FilterItem PE"));
%}
CHOICE
<<(parm->fi_type + 1)>>
{
equality
[0] AttributeValueAssertion [[p &(parm->fi_un.fi_un_ava)]]
%{
%} ,
substrings
%{
subs_temp = &(parm->UNSUB);
subs_type = 1;
if((avs_temp = subs_temp->fi_sub_initial) == NULLAV)
{
++subs_type;
if((avs_temp = subs_temp->fi_sub_any) == NULLAV)
{
++subs_type;
avs_temp = subs_temp->fi_sub_final;
}
}
%}
[1] SEQUENCE
{
type
AttributeType [[p subs_temp->fi_sub_type]]
%{
%} ,
strings
SEQUENCE OF
%{
%}
<<; avs_temp != NULLAV;>>
CHOICE
<<subs_type>>
{
initial
[0] AttributeValue [[p avs_temp->avseq_av]]
%{
if((avs_temp = avs_temp->avseq_next) == NULLAV)
{
++subs_type;
if((avs_temp = subs_temp->fi_sub_any) == NULLAV)
{
++subs_type;
avs_temp = subs_temp->fi_sub_final;
}
}
%} ,
any
[1] AttributeValue [[p avs_temp->avseq_av]]
%{
if((avs_temp = avs_temp->avseq_next) == NULLAV)
{
++subs_type;
avs_temp = subs_temp->fi_sub_final;
}
%} ,
final
[2] AttributeValue [[p avs_temp->avseq_av]]
%{
avs_temp = avs_temp->avseq_next;
%}
}
%{
%}
%{
%}
}
%{
%} ,
greaterOrEqual
[2] AttributeValueAssertion [[p &(parm->fi_un.fi_un_ava)]]
%{
%} ,
lessOrEqual
[3] AttributeValueAssertion [[p &(parm->fi_un.fi_un_ava)]]
%{
%} ,
present
[4] AttributeType [[p parm->fi_un.fi_un_type]]
%{
%} ,
approximateMatch
[5] AttributeValueAssertion [[p &(parm->fi_un.fi_un_ava)]]
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode FilterItem PE"));
%}
Filter [[P struct filter *]]
%{
Filter flt_temp;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode Filter PE"));
%}
CHOICE
<<(parm->flt_type + 1)>>
{
item
[0] FilterItem [[p &(parm->flt_un.flt_un_item)]]
%{
%} ,
and
[1] SET OF
%{
%}
<<flt_temp=parm->flt_un.flt_un_filter;flt_temp!=NULL;flt_temp=flt_temp->flt_next>>
Filter [[p flt_temp]]
%{
%}
%{
%} ,
or
[2] SET OF
%{
%}
<<flt_temp=parm->flt_un.flt_un_filter;flt_temp!=NULL;flt_temp=flt_temp->flt_next>>
Filter [[p flt_temp]]
%{
%}
%{
%} ,
not
[3] Filter [[p parm->flt_un.flt_un_filter]]
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode Filter PE"));
%}
EntryModification [[P struct entrymod *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode EntryModification PE"));
%}
CHOICE
<<(parm->em_type + 1)>>
{
addAttribute
[0] Attribute [[p parm->em_what]]
%{
%} ,
removeAttribute
[1] AttributeType [[p parm->em_what->attr_type]]
%{
%} ,
addValues
[2] Attribute [[p parm->em_what]]
%{
%} ,
removeValues
[3] Attribute [[p parm->em_what]]
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode EntryModification PE"));
%}
AbandonProblem [[P int]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode AbandonProblem PE"));
%}
INTEGER [[i parm]]
{
noSuchOperation(1) ,
tooLate(2) ,
cannotAbandon(3)
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode AbandonProblem PE"));
%}
AttributeProblem [[P int]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode AttributeProblem PE"));
%}
INTEGER [[i parm]]
{
noSuchAttributeOrValue(1) ,
invalidAttributeSyntax(2) ,
undefinedAttributeType(3) ,
inappropriateMatching(4) ,
constraintViolation(5) ,
attributeOrValueAlreadyExists(6)
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode AttributeProblem PE"));
%}
NameProblem [[P int]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode NameProblem PE"));
%}
INTEGER [[i parm]]
{
noSuchObject(1) ,
aliasProblem(2) ,
invalidAttributeSyntax(3) ,
aliasDereferencingProblem(4)
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode NameProblem PE"));
%}
UpdateProblem [[P int]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode UpdateProblem PE"));
%}
INTEGER [[i parm]]
{
namingViolation(1) ,
objectClassViolation(2) ,
notAllowedOnLeaf(3) ,
notAllowedOnRDN(4) ,
entryAlreadyExists(5) ,
affectsMultipleDSAs(6) ,
objectClassModificationProhibited(7)
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode UpdateProblem PE"));
%}
DirectoryBindArgument [[P struct ds_bind_arg *]]
%{
USC usc_s;
USC * usc = &(usc_s);
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode DirectoryBindArgument"));
usc->usc_dn = parm->dba_dn;
if((usc->usc_passwd_len = parm->dba_passwd_len) != 0)
{
usc->usc_passwd = strdup(parm->dba_passwd);
}
else
{
usc->usc_passwd = NULL;
}
%}
SET
{
credentials
[0] Credentials [[p usc]]
%{
%}
OPTIONAL <<usc->usc_dn != NULLDN>> ,
versions
[1] Versions [[p parm->dba_version]]
%{
%}
-- DEFAULT v1988 <<parm->dba_version != DBA_VERSION_V1988>>
OPTIONAL <<parm->dba_version != DBA_VERSION_V1988>>
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode DirectoryBindArgument"));
%}
DirectoryBindResult [[P struct ds_bind_arg *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode DirectoryBindResult"));
%}
DirectoryBindArgument [[p parm]]
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode DirectoryBindResult"));
%}
ReadArgumentData [[P struct ds_read_arg *]]
%{
struct common_args * ca;
struct extension * extp;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode ReadArgumentData PE"));
ca = &(parm->rda_common);
%}
SET
{
object
[0] Name [[p parm->rda_object]]
%{
%} ,
selection
[1] EntryInformationSelection [[p &(parm->rda_eis)]]
%{
%}
-- DEFAULT {} ,
OPTIONAL <<TRUE>> ,
[30] ServiceControls [[p &(ca->ca_servicecontrol)]]
%{
%}
-- DEFAULT {} ,
OPTIONAL <<TRUE>> ,
[29] SecurityParameters
-- DEFAULT {} ,
OPTIONAL <<FALSE>> ,
requestor
[28] DistinguishedName [[p ca->ca_requestor]]
%{
%}
OPTIONAL <<ca->ca_requestor != NULLDN>> ,
[27] OperationProgress [[p &(ca->ca_progress)]]
%{
%}
OPTIONAL <<TRUE>> ,
aliasedRDNs
[26] INTEGER [[i ca->ca_aliased_rdns]]
OPTIONAL <<ca->ca_aliased_rdns != CA_NO_ALIASDEREFERENCED>> ,
extensions
[25] SET OF
<<extp=ca->ca_extensions; extp!=NULLEXT; extp=extp->ext_next>>
Extension [[p extp]]
OPTIONAL <<ca->ca_extensions != NULLEXT>>
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode ReadArgumentData PE"));
%}
ReadArgument [[P struct ds_read_arg *]]
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At encode ReadArgument"));
%}
CHOICE
<<1>>
{
ReadArgumentData [[p parm]] ,
SEQUENCE
{
ReadArgumentData [[p parm]] ,
AlgorithmIdentifier ,
BIT STRING
}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode ReadArgument"));
%}
ReadResultData [[P struct ds_read_result *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode ReadResultData PE"));
%}
SET
{
entry
[0] EntryInformation [[p &(parm->rdr_entry)]]
%{
%} ,
[30] SecurityParameters
OPTIONAL <<FALSE>> ,
performer
[29] DistinguishedName [[p parm->rdr_common.cr_requestor]]
%{
%}
OPTIONAL <<parm->rdr_common.cr_requestor != NULLDN>> ,
aliasDereferenced
[28] BOOLEAN [[b parm->rdr_common.cr_aliasdereferenced]]
%{
%}
-- DEFAULT FALSE <<parm->rdr_common.cr_aliasdereferenced != FALSE>>
OPTIONAL <<parm->rdr_common.cr_aliasdereferenced != FALSE>>
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode ReadResultData PE"));
%}
ReadResult [[P struct ds_read_result *]]
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At encode ReadResult"));
%}
CHOICE
<<1>>
{
ReadResultData [[p parm]] ,
SEQUENCE
{
ReadResultData [[p parm]] ,
AlgorithmIdentifier ,
BIT STRING
}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode ReadResult"));
%}
CompareArgumentData [[P struct ds_compare_arg *]]
%{
struct common_args * ca;
struct extension * extp;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode CompareArgumentData PE"));
ca = &(parm->cma_common);
%}
SET
{
object
[0] Name [[p parm->cma_object]]
%{
%} ,
purported
[1] AttributeValueAssertion [[p &(parm->cma_purported)]]
%{
%} ,
[30] ServiceControls [[p &(ca->ca_servicecontrol)]]
%{
%}
-- DEFAULT {} ,
OPTIONAL <<TRUE>> ,
[29] SecurityParameters
-- DEFAULT {} ,
OPTIONAL <<FALSE>> ,
requestor
[28] DistinguishedName [[p ca->ca_requestor]]
%{
%}
OPTIONAL <<ca->ca_requestor != NULLDN>> ,
[27] OperationProgress [[p &(ca->ca_progress)]]
%{
%}
OPTIONAL <<TRUE>> ,
aliasedRDNs
[26] INTEGER [[i ca->ca_aliased_rdns]]
OPTIONAL <<ca->ca_aliased_rdns != CA_NO_ALIASDEREFERENCED>> ,
extensions
[25] SET OF
<<extp=ca->ca_extensions; extp!=NULLEXT; extp=extp->ext_next>>
Extension [[p extp]]
OPTIONAL <<ca->ca_extensions != NULLEXT>>
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode CompareArgumentData PE"));
%}
CompareArgument [[P struct ds_compare_arg *]]
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At encode CompareArgument"));
%}
CHOICE
<<1>>
{
CompareArgumentData [[p parm]] ,
SEQUENCE
{
CompareArgumentData [[p parm]] ,
AlgorithmIdentifier ,
BIT STRING
}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode CompareArgument"));
%}
CompareResultData [[P struct ds_compare_result *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode CompareResultData PE"));
%}
SET
{
DistinguishedName [[p parm->cmr_object]]
%{
%}
OPTIONAL <<parm->cmr_object != NULLDN>> ,
matched
[0] BOOLEAN [[b parm->cmr_matched]]
%{
%} ,
fromEntry
[1] BOOLEAN [[b parm->cmr_iscopy]]
%{
%}
-- DEFAULT TRUE <<parm->cmr_iscopy != TRUE>> ,
OPTIONAL <<parm->cmr_iscopy != TRUE>> ,
[30] SecurityParameters
OPTIONAL <<FALSE>> ,
performer
[29] DistinguishedName [[p parm->cmr_common.cr_requestor]]
%{
%}
OPTIONAL <<parm->cmr_common.cr_requestor != NULLDN>> ,
aliasDereferenced
[28] BOOLEAN [[b parm->cmr_common.cr_aliasdereferenced]]
%{
%}
-- DEFAULT FALSE <<parm->cmr_common.cr_aliasdereferenced != FALSE>>
OPTIONAL <<parm->cmr_common.cr_aliasdereferenced != FALSE>>
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode CompareResultData PE"));
%}
CompareResult [[P struct ds_compare_result *]]
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At encode CompareResult"));
%}
CHOICE
<<1>>
{
CompareResultData [[p parm]] ,
SEQUENCE
{
CompareResultData [[p parm]] ,
AlgorithmIdentifier ,
BIT STRING
}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode CompareResult"));
%}
AbandonArgument [[P struct ds_abandon_arg *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode AbandonArgument PE"));
%}
SEQUENCE
{
invokeID
[0] InvokeID [[p parm->aba_invokeid]]
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode AbandonArgument PE"));
%}
AbandonResult ::= NULL
ListArgumentData [[P struct ds_list_arg *]]
%{
struct common_args * ca;
struct extension * extp;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode ListArgumentData PE"));
ca = &(parm->lsa_common);
%}
SET
{
object
[0] Name [[p parm->lsa_object]]
%{
%} ,
[30] ServiceControls [[p &(ca->ca_servicecontrol)]]
%{
%}
-- DEFAULT {} ,
OPTIONAL <<TRUE>> ,
[29] SecurityParameters
-- DEFAULT {} ,
OPTIONAL <<FALSE>> ,
requestor
[28] DistinguishedName [[p ca->ca_requestor]]
%{
%}
OPTIONAL <<ca->ca_requestor != NULLDN>> ,
[27] OperationProgress [[p &(ca->ca_progress)]]
%{
%}
OPTIONAL <<TRUE>> ,
aliasedRDNs
[26] INTEGER [[i ca->ca_aliased_rdns]]
OPTIONAL <<ca->ca_aliased_rdns != CA_NO_ALIASDEREFERENCED>> ,
extensions
[25] SET OF
<<extp=ca->ca_extensions; extp!=NULLEXT; extp=extp->ext_next>>
Extension [[p extp]]
OPTIONAL <<ca->ca_extensions != NULLEXT>>
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode ListArgumentData PE"));
%}
ListArgument [[P struct ds_list_arg *]]
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At encode ListArgument"));
%}
CHOICE
<<1>>
{
ListArgumentData [[p parm]] ,
SEQUENCE
{
ListArgumentData [[p parm]] ,
AlgorithmIdentifier ,
BIT STRING
}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode ListArgument"));
%}
ListResultData [[P struct ds_list_result *]]
%{
struct subordinate *sub_temp;
POQ poq_s;
POQ * poq = &(poq_s);
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode ListResultData PE"));
poq->poq_limitproblem = parm->lsr_limitproblem;
poq->poq_cref = parm->lsr_cr;
%}
CHOICE
<<1>>
{
listInfo
SET
{
DistinguishedName [[p parm->lsr_object]]
%{
%}
OPTIONAL <<parm->lsr_object != NULLDN>> ,
subordinates
[1] SET OF
%{
%}
<<sub_temp=parm->lsr_subordinates;sub_temp!=NULL;sub_temp=sub_temp->sub_next>>
SEQUENCE
{
RelativeDistinguishedName [[p sub_temp->sub_rdn]]
%{
%} ,
aliasEntry
[0] BOOLEAN [[b sub_temp->sub_aliasentry]]
%{
%}
-- DEFAULT FALSE <<sub_temp->sub_aliasentry != FALSE>> ,
OPTIONAL <<sub_temp->sub_aliasentry != FALSE>> ,
fromEntry
[1] BOOLEAN [[b sub_temp->sub_copy]]
%{
%}
-- DEFAULT TRUE <<sub_temp->sub_copy != TRUE>>
OPTIONAL <<sub_temp->sub_copy != TRUE>>
}
%{
%}
%{
%} ,
partialOutcomeQualifier
[2] PartialOutcomeQualifier [[p poq]]
%{
%}
OPTIONAL <<parm->lsr_limitproblem != LSR_NOLIMITPROBLEM>> ,
[30] SecurityParameters
OPTIONAL <<FALSE>> ,
performer
[29] DistinguishedName [[p parm->lsr_common.cr_requestor]]
%{
%}
OPTIONAL <<parm->lsr_common.cr_requestor != NULLDN>> ,
aliasDereferenced
[28] BOOLEAN [[b parm->lsr_common.cr_aliasdereferenced]]
%{
%}
-- DEFAULT FALSE <<parm->lsr_common.cr_aliasdereferenced != FALSE>>
OPTIONAL <<parm->lsr_common.cr_aliasdereferenced != FALSE>>
}
%{
%} ,
uncorrelatedListInfo
[0] SET OF
ListResult [[p ((struct ds_list_result *) 0)]]
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode ListResultData PE"));
%}
ListResult [[P struct ds_list_result *]]
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At encode ListResult"));
%}
CHOICE
<<1>>
{
ListResultData [[p parm]] ,
SEQUENCE
{
ListResultData [[p parm]] ,
AlgorithmIdentifier ,
BIT STRING
}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode ListResult"));
%}
SearchArgumentData [[P struct ds_search_arg *]]
%{
struct common_args * ca;
struct extension * extp;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode SearchArgumentData PE"));
ca = &(parm->sra_common);
%}
SET
{
baseObject
[0] Name [[p parm->sra_baseobject]]
%{
%} ,
subset
[1] INTEGER [[i parm->sra_subset]]
{
baseObject(0) ,
oneLevel(1) ,
wholeSubtree(2)
}
%{
%}
-- DEFAULT baseObject <<parm->sra_subset != SRA_BASEOBJECT>> ,
OPTIONAL <<parm->sra_subset != SRA_BASEOBJECT>> ,
filter
[2] Filter [[p parm->sra_filter]]
%{
%}
-- DEFAULT and {} ,
OPTIONAL <<TRUE>> ,
searchAliases
[3] BOOLEAN
-- DEFAULT TRUE ,
OPTIONAL <<FALSE>> ,
selection
[4] EntryInformationSelection [[p &(parm->sra_eis)]]
%{
%}
-- DEFAULT {} ,
OPTIONAL <<TRUE>> ,
[30] ServiceControls [[p &(ca->ca_servicecontrol)]]
%{
%}
-- DEFAULT {} ,
OPTIONAL <<TRUE>> ,
[29] SecurityParameters
-- DEFAULT {} ,
OPTIONAL <<FALSE>> ,
requestor
[28] DistinguishedName [[p ca->ca_requestor]]
%{
%}
OPTIONAL <<ca->ca_requestor != NULLDN>> ,
[27] OperationProgress [[p &(ca->ca_progress)]]
%{
%}
OPTIONAL <<TRUE>> ,
aliasedRDNs
[26] INTEGER [[i ca->ca_aliased_rdns]]
OPTIONAL <<ca->ca_aliased_rdns != CA_NO_ALIASDEREFERENCED>> ,
extensions
[25] SET OF
<<extp=ca->ca_extensions; extp!=NULLEXT; extp=extp->ext_next>>
Extension [[p extp]]
OPTIONAL <<ca->ca_extensions != NULLEXT>>
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode SearchArgumentData PE"));
%}
SearchArgument [[P struct ds_search_arg *]]
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At encode SearchArgument"));
%}
CHOICE
<<1>>
{
SearchArgumentData [[p parm]] ,
SEQUENCE
{
SearchArgumentData [[p parm]] ,
AlgorithmIdentifier ,
BIT STRING
}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode SearchArgument"));
%}
SearchResultData [[P struct ds_search_result *]]
%{
struct ds_search_result *srr_temp;
EntryInfo *ent_temp;
POQ poq_s;
POQ * poq = &(poq_s);
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode SearchResultData PE"));
%}
CHOICE
<<((parm->srr_correlated == FALSE) ? 2 : 1)>>
{
searchInfo
%{
poq->poq_limitproblem = parm->CSR_limitproblem;
poq->poq_cref = parm->CSR_cr;
%}
SET
{
DistinguishedName [[p parm->CSR_object]]
%{
%}
OPTIONAL <<parm->CSR_object != NULLDN>> ,
entries
[0] SET OF
%{
%}
<<ent_temp=parm->CSR_entries;ent_temp!=NULLENTRYINFO;ent_temp=ent_temp->ent_next>>
EntryInformation [[p ent_temp]]
%{
%}
%{
%} ,
partialOutcomeQualifier
[2] PartialOutcomeQualifier [[p poq]]
%{
%}
OPTIONAL <<((poq->poq_limitproblem != LSR_NOLIMITPROBLEM) || (poq->poq_cref != NULLCONTINUATIONREF))>> ,
[30] SecurityParameters
OPTIONAL <<FALSE>> ,
performer
[29] DistinguishedName [[p parm->CSR_common.cr_requestor]]
%{
%}
OPTIONAL <<parm->CSR_common.cr_requestor != NULLDN>> ,
aliasDereferenced
[28] BOOLEAN [[b parm->CSR_common.cr_aliasdereferenced]]
%{
%}
-- DEFAULT FALSE <<parm->CSR_common.cr_aliasdereferenced != FALSE>>
OPTIONAL <<parm->CSR_common.cr_aliasdereferenced != FALSE>>
}
%{
%} ,
uncorrelatedSearchInfo
[0] SET OF
%{
%}
<<srr_temp=parm->srr_un.srr_parts;srr_temp!=NULLSRR;srr_temp=srr_temp->srr_next>>
SearchResult [[p srr_temp]]
%{
%}
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode SearchResultData PE"));
%}
SearchResult [[P struct ds_search_result *]]
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At encode SearchResult"));
%}
CHOICE
<<1>>
{
SearchResultData [[p parm]] ,
SEQUENCE
{
SearchResultData [[p parm]] ,
AlgorithmIdentifier ,
BIT STRING
}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode SearchResult"));
%}
AddEntryArgumentData [[P struct ds_addentry_arg *]]
%{
struct common_args * ca;
struct extension * extp;
Attr_Sequence attr_temp;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode AddEntryArgumentData PE"));
ca = &(parm->ada_common);
%}
SET
{
object
[0] DistinguishedName [[p parm->ada_object]]
%{
%} ,
entry
[1] SET OF
%{
%}
<<attr_temp=parm->ada_entry;attr_temp!=NULLATTR;attr_temp=attr_temp->attr_link>>
Attribute [[p attr_temp]]
%{
%}
%{
%} ,
[30] ServiceControls [[p &(ca->ca_servicecontrol)]]
%{
%}
-- DEFAULT {} ,
OPTIONAL <<TRUE>> ,
[29] SecurityParameters
-- DEFAULT {} ,
OPTIONAL <<FALSE>> ,
requestor
[28] DistinguishedName [[p ca->ca_requestor]]
%{
%}
OPTIONAL <<ca->ca_requestor != NULLDN>> ,
[27] OperationProgress [[p &(ca->ca_progress)]]
%{
%}
OPTIONAL <<TRUE>> ,
aliasedRDNs
[26] INTEGER [[i ca->ca_aliased_rdns]]
OPTIONAL <<ca->ca_aliased_rdns != CA_NO_ALIASDEREFERENCED>> ,
extensions
[25] SET OF
<<extp=ca->ca_extensions; extp!=NULLEXT; extp=extp->ext_next>>
Extension [[p extp]]
OPTIONAL <<ca->ca_extensions != NULLEXT>>
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode AddEntryArgumentData PE"));
%}
AddEntryArgument [[P struct ds_addentry_arg *]]
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At encode AddEntryArgument"));
%}
CHOICE
<<1>>
{
AddEntryArgumentData [[p parm]] ,
SEQUENCE
{
AddEntryArgumentData [[p parm]] ,
AlgorithmIdentifier ,
BIT STRING
}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode AddEntryArgument"));
%}
AddEntryResult ::= NULL
RemoveEntryArgumentData [[P struct ds_removeentry_arg *]]
%{
struct common_args * ca;
struct extension * extp;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode RemoveEntryArgumentData PE"));
ca = &(parm->rma_common);
%}
SET
{
object
[0] DistinguishedName [[p parm->rma_object]]
%{
%} ,
[30] ServiceControls [[p &(ca->ca_servicecontrol)]]
%{
%}
-- DEFAULT {} ,
OPTIONAL <<TRUE>> ,
[29] SecurityParameters
-- DEFAULT {} ,
OPTIONAL <<FALSE>> ,
requestor
[28] DistinguishedName [[p ca->ca_requestor]]
%{
%}
OPTIONAL <<ca->ca_requestor != NULLDN>> ,
[27] OperationProgress [[p &(ca->ca_progress)]]
%{
%}
OPTIONAL <<TRUE>> ,
aliasedRDNs
[26] INTEGER [[i ca->ca_aliased_rdns]]
OPTIONAL <<ca->ca_aliased_rdns != CA_NO_ALIASDEREFERENCED>> ,
extensions
[25] SET OF
<<extp=ca->ca_extensions; extp!=NULLEXT; extp=extp->ext_next>>
Extension [[p extp]]
OPTIONAL <<ca->ca_extensions != NULLEXT>>
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode RemoveEntryArgumentData PE"));
%}
RemoveEntryArgument [[P struct ds_removeentry_arg *]]
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At encode RemoveEntryArgument"));
%}
CHOICE
<<1>>
{
RemoveEntryArgumentData [[p parm]] ,
SEQUENCE
{
RemoveEntryArgumentData [[p parm]] ,
AlgorithmIdentifier ,
BIT STRING
}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode RemoveEntryArgument"));
%}
RemoveEntryResult ::= NULL
ModifyEntryArgumentData [[P struct ds_modifyentry_arg *]]
%{
struct common_args * ca;
struct extension * extp;
struct entrymod *em_temp;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode ModifyEntryArgumentData PE"));
ca = &(parm->mea_common);
%}
SET
{
object
[0] DistinguishedName [[p parm->mea_object]]
%{
%} ,
changes
[1] SEQUENCE OF
%{
%}
<<em_temp=parm->mea_changes;em_temp!=NULL;em_temp=em_temp->em_next>>
EntryModification [[p em_temp]]
%{
%}
%{
%} ,
[30] ServiceControls [[p &(ca->ca_servicecontrol)]]
%{
%}
-- DEFAULT {} ,
OPTIONAL <<TRUE>> ,
[29] SecurityParameters
-- DEFAULT {} ,
OPTIONAL <<FALSE>> ,
requestor
[28] DistinguishedName [[p ca->ca_requestor]]
%{
%}
OPTIONAL <<ca->ca_requestor != NULLDN>> ,
[27] OperationProgress [[p &(ca->ca_progress)]]
%{
%}
OPTIONAL <<TRUE>> ,
aliasedRDNs
[26] INTEGER [[i ca->ca_aliased_rdns]]
OPTIONAL <<ca->ca_aliased_rdns != CA_NO_ALIASDEREFERENCED>> ,
extensions
[25] SET OF
<<extp=ca->ca_extensions; extp!=NULLEXT; extp=extp->ext_next>>
Extension [[p extp]]
OPTIONAL <<ca->ca_extensions != NULLEXT>>
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode ModifyEntryArgumentData PE"));
%}
ModifyEntryArgument [[P struct ds_modifyentry_arg *]]
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At encode ModifyEntryArgument"));
%}
CHOICE
<<1>>
{
ModifyEntryArgumentData [[p parm]] ,
SEQUENCE
{
ModifyEntryArgumentData [[p parm]] ,
AlgorithmIdentifier ,
BIT STRING
}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode ModifyEntryArgument"));
%}
ModifyEntryResult ::= NULL
ModifyRDNArgumentData [[P struct ds_modifyrdn_arg *]]
%{
struct common_args * ca;
struct extension * extp;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode ModifyRDNArgumentData PE"));
ca = &(parm->mra_common);
%}
SET
{
object
[0] DistinguishedName [[p parm->mra_object]]
%{
%} ,
newRDN
[1] RelativeDistinguishedName [[p parm->mra_newrdn]]
%{
%} ,
deleteRDN
[2] BOOLEAN [[b parm->deleterdn]]
%{
%}
-- DEFAULT FALSE <<parm->deleterdn != FALSE>> ,
OPTIONAL <<parm->deleterdn != FALSE>> ,
[30] ServiceControls [[p &(ca->ca_servicecontrol)]]
%{
%}
-- DEFAULT {} ,
OPTIONAL <<TRUE>> ,
[29] SecurityParameters
-- DEFAULT {} ,
OPTIONAL <<FALSE>> ,
requestor
[28] DistinguishedName [[p ca->ca_requestor]]
%{
%}
OPTIONAL <<ca->ca_requestor != NULLDN>> ,
[27] OperationProgress [[p &(ca->ca_progress)]]
%{
%}
OPTIONAL <<TRUE>> ,
aliasedRDNs
[26] INTEGER [[i ca->ca_aliased_rdns]]
OPTIONAL <<ca->ca_aliased_rdns != CA_NO_ALIASDEREFERENCED>> ,
extensions
[25] SET OF
<<extp=ca->ca_extensions; extp!=NULLEXT; extp=extp->ext_next>>
Extension [[p extp]]
OPTIONAL <<ca->ca_extensions != NULLEXT>>
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode ModifyRDNArgumentData PE"));
%}
ModifyRDNArgument [[P struct ds_modifyrdn_arg *]]
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At encode ModifyRDNArgument"));
%}
CHOICE
<<1>>
{
ModifyRDNArgumentData [[p parm]] ,
SEQUENCE
{
ModifyRDNArgumentData [[p parm]] ,
AlgorithmIdentifier ,
BIT STRING
}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode ModifyRDNArgument"));
%}
ModifyRDNResult ::= NULL
DirectoryBindError [[P struct ds_bind_error *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode DirectoryBindError"));
%}
SET
{
versions
[0] Versions [[p parm->dbe_version]]
%{
%}
-- DEFAULT v1988 <<parm->dbe_version != DBA_VERSION_V1988>> ,
OPTIONAL <<parm->dbe_version != DBA_VERSION_V1988>> ,
CHOICE
<<(parm->dbe_type + 1)>>
{
serviceError
[1] ServiceProblem [[p parm->dbe_value]]
%{
%} ,
securityError
[2] SecurityProblem [[p parm->dbe_value]]
%{
%}
}
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode DirectoryBindError"));
%}
AbandonedParm ::= NULL
AbandonFailedParm [[P struct DSE_abandon_fail *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode AbandonFailedParm PE"));
%}
SET
%{
%}
{
problem
[0] AbandonProblem [[p parm->DSE_ab_problem]]
%{
%} ,
operation
[1] InvokeID [[p parm->DSE_ab_invokeid]]
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode AbandonFailedParm PE"));
%}
AttributeErrorParm [[P struct DSE_attribute *]]
%{
struct DSE_at_problem *atp;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode AttributeErrorParm PE"));
%}
SET
%{
%}
{
object
[0] Name [[p parm->DSE_at_name]]
%{
%} ,
problems
[1] SET OF
%{
%}
<<atp = &(parm->DSE_at_plist);(atp!=DSE_AT_NOPROBLEM) && atp->DSE_at_what;atp=atp->dse_at_next>>
SEQUENCE
%{
%}
{
problem
[0] AttributeProblem [[p atp->DSE_at_what]]
%{
%} ,
type
[1] AttributeType [[p atp->DSE_at_type]]
%{
%} ,
value
[2] AttributeValue [[p atp->DSE_at_value]]
%{
%}
OPTIONAL <<atp->DSE_at_value != NULLAttrV>>
}
%{
%}
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode AttributeErrorParm PE"));
%}
NameErrorParm [[P struct DSE_name *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode NameErrorParm PE"));
%}
SET
%{
%}
{
problem
[0] NameProblem [[p parm->DSE_na_problem]]
%{
%} ,
matched
[1] Name [[p parm->DSE_na_matched]]
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode NameErrorParm PE"));
%}
ReferralParm [[P struct DSE_referral *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode ReferralParm PE"));
%}
SET
%{
%}
{
candidate
[0] ContinuationReference [[p parm->DSE_ref_candidates]]
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode ReferralParm PE"));
%}
SecurityErrorParm [[P struct DSE_security *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode SecurityErrorParm PE"));
%}
SET
%{
%}
{
problem
[0] SecurityProblem [[p parm->DSE_sc_problem]]
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode SecurityErrorParm PE"));
%}
ServiceErrorParm [[P struct DSE_service *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode ServiceErrorParm PE"));
%}
SET
%{
%}
{
problem
[0] ServiceProblem [[p parm->DSE_sv_problem]]
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode ServiceErrorParm PE"));
%}
UpdateErrorParm [[P struct DSE_update *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to encode UpdateErrorParm PE"));
%}
SET
%{
%}
{
problem
[0] UpdateProblem [[p parm->DSE_up_problem]]
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done encode UpdateErrorParm PE"));
%}
END