|
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: 68712 (0x10c68)
Types: TextFile
Names: »das-dec.py«
└─⟦2d1937cfd⟧ Bits:30007241 EUUGD22: P.P 5.0
└─⟦35176feda⟧ »EurOpenD22/isode/isode-6.tar.Z«
└─⟦de7628f85⟧
└─⟦this⟧ »isode-6.0/dsap/x500as/das-dec.py«
-- das-dec.py - manually augmented DirectoryAbstractService module
-- $Header: /f/osi/dsap/x500as/RCS/das-dec.py,v 7.0 89/11/23 21:50:06 mrose Rel $
--
--
-- $Log: das-dec.py,v $
-- Revision 7.0 89/11/23 21:50:06 mrose
-- Release 6.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"
#include "quipu/bind.h"
extern LLog * log_dsap;
#define decode_UNIV_UTCTime parse_UNIV_UTCTime
%}
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 ,
-- 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)
};
DECODER decode
SimpleCredentials [[P struct ds_bind_arg *]]
%{
char *passwd;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode SimpleCredentials (DAS)"));
parm->dba_dn = NULLDN;
parm->dba_passwd_len = 0;
parm->dba_passwd[0] = '\0';
parm->dba_time1 = NULLCP;
parm->dba_time2 = NULLCP;
parm->dba_r1.value = NULLCP;
parm->dba_r1.n_bits = 0;
parm->dba_r2.value = NULLCP;
parm->dba_r2.n_bits = 0;
parm->dba_auth_type = DBA_AUTH_NONE;
%}
SEQUENCE
{
name
[0] DistinguishedName [[p &(parm->dba_dn)]]
%{
%} ,
validity
[1] SET
%{
%}
{
time1
[0] UTCTime [[s parm -> dba_time1]]
%{
%} OPTIONAL ,
time2
[1] UTCTime [[s parm -> dba_time2]]
%{
%} OPTIONAL ,
random1
[2] BIT STRING [[x parm->dba_r1.value $ parm->dba_r1.n_bits]]
OPTIONAL ,
random2
[3] BIT STRING [[x parm->dba_r2.value $ parm->dba_r2.n_bits]]
OPTIONAL
}
%{
parm->dba_auth_type = DBA_AUTH_PROTECTED;
%} OPTIONAL ,
password
[2] OCTET STRING [[o passwd $ parm->dba_passwd_len]]
%{
bcopy(passwd, parm->dba_passwd, parm->dba_passwd_len);
free(passwd);
if (parm->dba_auth_type == DBA_AUTH_NONE)
parm->dba_auth_type = DBA_AUTH_SIMPLE;
%}
OPTIONAL
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode SimpleCredentials"));
%}
TokenToSign [[P struct ds_bind_arg *]]
%{
struct alg_id alg;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode TokenToSign (DAS)"));
%}
SEQUENCE
{
algorithm
[0] AlgorithmIdentifier [[p &alg]],
name
[1] DistinguishedName [[p &(parm->dba_dn)]]
%{
%} ,
time
[2] UTCTime [[s parm->dba_time1]],
random
[3] BIT STRING [[x parm->dba_r1.value $ parm->dba_r1.n_bits ]]
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode TokenToSign (DAS)"));
%}
Token [[P struct ds_bind_arg *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode Token (DAS)"));
parm->dba_sig = (struct signature *)
calloc(1, sizeof(struct signature));
%}
SEQUENCE
{
TokenToSign [[p parm]],
AlgorithmIdentifier [[p &(parm->dba_sig->alg)]],
BIT STRING [[x parm->dba_sig->encrypted $ parm->dba_sig->n_bits]]
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode Token (DAS)"));
%}
StrongCredentials [[P struct ds_bind_arg *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode StrongCredentials (DAS)"));
%}
SET
{
certificationPath
[0] CertificationPath [[p &(parm->dba_cpath)]]
OPTIONAL ,
bindToken
[1] Token [[p parm]]
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode StrongCredentials (DAS)"));
%}
Credentials [[P struct ds_bind_arg *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode Credentials (DAS)"));
%}
CHOICE
{
simple
[0] SimpleCredentials [[p parm]]
%{
%} ,
strong
[1] StrongCredentials [[p parm]]
%{
parm->dba_auth_type = DBA_AUTH_STRONG;
%} ,
externalProcedure
[2] EXTERNAL
%{
parm->dba_auth_type = DBA_AUTH_EXTERNAL;
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode Credentials (DAS)"));
%}
Versions [[P int*]]
%{
int ver_len;
char *ver_bits;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode Versions"));
%}
BIT STRING [[x ver_bits $ ver_len]]
{
v1988(0)
}
%{
(*parm) = strb2int(ver_bits ,ver_len);
/*
interworking HACK 'till 1992 !!!
*/
(*parm) = DBA_VERSION_V1988;
free (ver_bits);
DLOG(log_dsap, LLOG_TRACE, ("Done decode Versions"));
%}
SecurityProblem [[P int*]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode SecurityProblem"));
(*parm) = 0;
%}
INTEGER [[i (*parm)]]
{
inappropriateAuthentication(1) ,
invalidCredentials(2) ,
insufficientAccessRights(3) ,
invalidSignature(4) ,
protectionRequired(5) ,
noInformation(6)
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode SecurityProblem"));
%}
ServiceProblem [[P int*]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode ServiceProblem"));
(*parm) = 0;
%}
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 decode ServiceProblem"));
%}
EntryInformationSelection [[P struct entryinfoselection *]]
%{
Attr_Sequence *attr_link;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode EntryInformationSelection"));
parm->eis_allattributes = TRUE;
parm->eis_select = NULLATTR;
parm->eis_infotypes = EIS_ATTRIBUTESANDVALUES;
attr_link = &(parm->eis_select);
%}
SET
{
attributeTypes
CHOICE
{
allAttributes
[0] NULL
%{
parm->eis_allattributes = TRUE;
%} ,
select
[1] SET OF
%{
(*attr_link) = as_comp_alloc();
(*attr_link)->attr_value = NULLAV;
(*attr_link)->attr_acl = NULLACL_INFO;
%}
AttributeType [[p &((*attr_link)->attr_type)]]
%{
attr_link = &((*attr_link)->attr_link);
%}
%{
(*attr_link) = NULLATTR;
parm->eis_allattributes = FALSE;
%}
}
%{
%}
-- DEFAULT allAttributes NULL ,
OPTIONAL ,
infoTypes
[2] INTEGER [[i parm->eis_infotypes]]
{
attributeTypesOnly(0) ,
attributeTypesAndValues(1)
}
%{
%}
-- DEFAULT attributeTypesAndValues
OPTIONAL
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode EntryInformationSelection"));
%}
ServiceControls [[P struct svccontrol *]]
%{
char *opt_bits;
int opt_len;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode ServiceControls"));
parm->svc_options = 0;
parm->svc_prio = SVC_PRIO_MED;
parm->svc_timelimit = SVC_NOTIMELIMIT;
parm->svc_sizelimit = SVC_NOSIZELIMIT;
parm->svc_scopeofreferral = SVC_REFSCOPE_NONE;
%}
SET
{
options
[0] BIT STRING [[x opt_bits $ opt_len]]
{
preferChaining(0) ,
chainingProhibited(1) ,
localScope(2) ,
dontUseCopy(3) ,
dontDereferenceAliases(4)
}
%{
parm->svc_options = strb2int(opt_bits ,opt_len);
free (opt_bits);
%}
-- DEFAULT {} ,
OPTIONAL ,
priority
[1] INTEGER [[i parm->svc_prio]]
{
low(0) ,
medium(1) ,
high(2)
}
%{
%}
-- DEFAULT medium ,
OPTIONAL ,
timeLimit
[2] INTEGER [[i parm->svc_timelimit]]
%{
%}
OPTIONAL ,
sizeLimit
[3] INTEGER [[i parm->svc_sizelimit]]
%{
%}
OPTIONAL ,
scopeOfReferral
[4] INTEGER [[i parm->svc_scopeofreferral]]
{
dmd(0) ,
country(1)
}
OPTIONAL
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode ServiceControls"));
%}
ProtectionRequest [[P int *]]
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At decode ProtectionRequest"));
%}
INTEGER [[i (*parm)]]
{
none (0) ,
signed (1)
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode ProtectionRequest"));
%}
SecurityParameters [[P struct security_parms **]]
%{
struct security_parms *dummy = (struct security_parms *) 0;
int prot;
struct random_number random;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At decode SecurityParameters"));
if (parm == (struct security_parms **) 0)
parm = &dummy;
(*parm) = (struct security_parms *)
calloc(1, sizeof(struct security_parms));
(*parm)->sp_path = (struct certificate_list *) 0;
(*parm)->sp_name = NULLDN;
(*parm)->sp_time = NULLCP;
(*parm)->sp_random = (struct random_number *) 0;
(*parm)->sp_target = (char) 0;
%}
SET
{
certificationPath
[0] CertificationPath [[p &((*parm)->sp_path)]]
OPTIONAL ,
name
[1] DistinguishedName [[p &((*parm)->sp_name)]]
OPTIONAL ,
time
[2] UTCTime [[s ((*parm)->sp_time)]]
OPTIONAL ,
random
[3] BIT STRING [[x random.value $ random.n_bits]]
%{
(*parm)->sp_random = (struct random_number *)
calloc(1, sizeof(struct random_number));
bcopy((char *)&random, (char *)&((*parm)->sp_random), sizeof(struct random_number));
%}
OPTIONAL ,
target
[4] ProtectionRequest [[p &prot]]
%{
(*parm)->sp_target = (char) prot;
%}
OPTIONAL
}
%{
if (dummy)
cfree((char *) dummy);
DLOG(log_dsap, LLOG_TRACE, ("Done decode SecurityParameters"));
%}
Extension [[P struct extension *]]
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At decode Extension"));
LLOG(log_dsap, LLOG_FATAL, ("Some smartass Extension!!!"));
parm->ext_critical = FALSE;
parm->ext_item = NULLPE;
%}
SET
{
identifier
[0] INTEGER [[i parm->ext_id]] ,
critical
[1] BOOLEAN [[b parm->ext_critical]]
-- DEFAULT FALSE ,
OPTIONAL ,
item
[2] ANY DEFINED BY identifier [[a parm->ext_item]]
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode Extension"));
%}
EntryInformation [[P struct entrystruct *]]
%{
Attr_Sequence attr_tmp;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode EntryInformation"));
parm->ent_dn = NULLDN;
parm->ent_attr = NULLATTR;
parm->ent_iscopy = E_DATA_MASTER;
parm->ent_next = NULLENTRYINFO;
%}
SEQUENCE
{
DistinguishedName [[p &(parm->ent_dn)]]
%{
%} ,
fromEntry
BOOLEAN [[b parm->ent_iscopy]]
%{
%}
-- DEFAULT TRUE ,
OPTIONAL ,
SET OF
%{
attr_tmp = as_comp_alloc();
attr_tmp->attr_value = NULLAV;
attr_tmp->attr_acl = NULLACL_INFO;
attr_tmp->attr_link = NULLATTR;
%}
CHOICE
{
AttributeType [[p &(attr_tmp->attr_type)]]
%{
%} ,
Attribute [[p attr_tmp]]
%{
%}
}
%{
parm->ent_attr = as_merge(parm->ent_attr, attr_tmp);
%}
OPTIONAL
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode EntryInformation"));
%}
LimitProblem [[P int*]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode LimitProblem"));
%}
INTEGER [[i (*parm)]]
{
timeLimitExceeded(0) ,
sizeLimitExceeded(1) ,
administrativeLimitExceeded(2)
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode LimitProblem"));
%}
PartialOutcomeQualifier [[P struct part_outcome *]]
%{
ContinuationRef *crefp;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode PartialOutcomeQualifier"));
parm->poq_limitproblem = LSR_NOLIMITPROBLEM;
parm->poq_cref = NULLCONTINUATIONREF;
crefp = &(parm->poq_cref);
%}
SET
{
limitProblem
[0] LimitProblem [[p &(parm->poq_limitproblem)]]
%{
%}
OPTIONAL ,
unexplored
[1] SET OF
%{
(*crefp) = (ContinuationRef) smalloc(sizeof(continuation_ref));
%}
ContinuationReference [[p (*crefp)]]
%{
crefp = &((*crefp)->cr_next);
%}
%{
(*crefp) = NULLCONTINUATIONREF;
%}
OPTIONAL ,
unavailableCriticalExtensions
[2] BOOLEAN [[b parm->poq_no_ext]]
-- DEFAULT FALSE
OPTIONAL
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode PartialOutcomeQualifier"));
%}
FilterItem [[P struct filter_item *]]
%{
AV_Sequence * avs_initial;
AV_Sequence * avs_any;
AV_Sequence * avs_final;
AttributeValue av_next;
Filter_Substrings *subs_next;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode FilterItem"));
%}
CHOICE
{
equality
%{
parm->fi_type = FILTERITEM_EQUALITY;
%}
[0] AttributeValueAssertion [[p &(parm->fi_un.fi_un_ava)]]
%{
%} ,
substrings
%{
parm->fi_type = FILTERITEM_SUBSTRINGS;
subs_next = &(parm->fi_un.fi_un_substrings);
subs_next->fi_sub_type = AttrT_alloc();
subs_next->fi_sub_initial = NULLAV;
subs_next->fi_sub_any = NULLAV;
subs_next->fi_sub_final = NULLAV;
avs_initial = &(subs_next->fi_sub_initial);
avs_any = &(subs_next->fi_sub_any);
avs_final = &(subs_next->fi_sub_final);
%}
[1] SEQUENCE
{
type
AttributeType [[p subs_next->fi_sub_type]]
%{
%} ,
strings
SEQUENCE OF
%{
av_next = AttrV_alloc();
%}
CHOICE
{
initial
[0] AttributeValue [[p av_next]]
%{
(*avs_initial) = avs_comp_new(av_next);
avs_initial = &((*avs_initial)->avseq_next);
(*avs_initial) = NULLAV;
%} ,
any
[1] AttributeValue [[p av_next]]
%{
(*avs_any) = avs_comp_new(av_next);
avs_any = &((*avs_any)->avseq_next);
(*avs_any) = NULLAV;
%} ,
final
[2] AttributeValue [[p av_next]]
%{
(*avs_final) = avs_comp_new(av_next);
avs_final = &((*avs_final)->avseq_next);
(*avs_final) = NULLAV;
%}
}
%{
%}
%{
%}
}
%{
%} ,
greaterOrEqual
%{
parm->fi_type = FILTERITEM_GREATEROREQUAL;
%}
[2] AttributeValueAssertion [[p &(parm->fi_un.fi_un_ava)]]
%{
%} ,
lessOrEqual
%{
parm->fi_type = FILTERITEM_LESSOREQUAL;
%}
[3] AttributeValueAssertion [[p &(parm->fi_un.fi_un_ava)]]
%{
%} ,
present
%{
parm->fi_type = FILTERITEM_PRESENT;
parm->fi_un.fi_un_type = AttrT_alloc();
%}
[4] AttributeType [[p parm->fi_un.fi_un_type]]
%{
%} ,
approximateMatch
%{
parm->fi_type = FILTERITEM_APPROX;
%}
[5] AttributeValueAssertion [[p &(parm->fi_un.fi_un_ava)]]
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode FilterItem"));
%}
Filter [[P struct filter *]]
%{
Filter *flt_next;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode Filter"));
parm->flt_next = NULLFILTER;
flt_next = &(parm->flt_un.flt_un_filter);
(*flt_next) = NULLFILTER;
%}
CHOICE
{
item
%{
parm->flt_type = FILTER_ITEM;
%}
[0] FilterItem [[p &(parm->flt_un.flt_un_item)]]
%{
%} ,
and
%{
parm->flt_type = FILTER_AND;
%}
[1] SET OF
%{
(*flt_next) = filter_alloc();
%}
Filter [[p (*flt_next)]]
%{
flt_next = &((*flt_next)->flt_next);
%}
%{
(*flt_next) = NULLFILTER;
%} ,
or
%{
parm->flt_type = FILTER_OR;
%}
[2] SET OF
%{
(*flt_next) = filter_alloc();
%}
Filter [[p (*flt_next)]]
%{
flt_next = &((*flt_next)->flt_next);
%}
%{
(*flt_next) = NULLFILTER;
%} ,
not
%{
parm->flt_type = FILTER_NOT;
parm->flt_next = NULLFILTER;
(*flt_next) = filter_alloc();
%}
[3] Filter [[p (*flt_next)]]
%{
%}
%{
(*flt_next)->flt_next = NULLFILTER;
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode Filter"));
%}
EntryModification [[P struct entrymod *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode EntryModification"));
parm->em_type = 0;
parm->em_what = NULLATTR;
parm->em_next = NULL;
%}
CHOICE
{
addAttribute
%{
parm->em_type = EM_ADDATTRIBUTE;
parm->em_what = as_comp_alloc();
%}
[0] Attribute [[p parm->em_what]]
%{
%} ,
removeAttribute
%{
parm->em_type = EM_REMOVEATTRIBUTE;
parm->em_what = as_comp_new(NULLAttrT ,NULLAV ,NULLACL_INFO);
%}
[1] AttributeType [[p &(parm->em_what->attr_type)]]
%{
%} ,
addValues
%{
parm->em_type = EM_ADDVALUES;
parm->em_what = as_comp_alloc();
%}
[2] Attribute [[p parm->em_what]]
%{
%} ,
removeValues
%{
parm->em_type = EM_REMOVEVALUES;
parm->em_what = as_comp_alloc();
%}
[3] Attribute [[p parm->em_what]]
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode EntryModification"));
%}
AbandonProblem [[P int*]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode AbandonProblem"));
%}
INTEGER [[i (*parm)]]
{
noSuchOperation(1) ,
tooLate(2) ,
cannotAbandon(3)
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode AbandonProblem"));
%}
AttributeProblem [[P int*]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode AttributeProblem"));
%}
INTEGER [[i (*parm)]]
{
noSuchAttributeOrValue(1) ,
invalidAttributeSyntax(2) ,
undefinedAttributeType(3) ,
inappropriateMatching(4) ,
constraintViolation(5) ,
attributeOrValueAlreadyExists(6)
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode AttributeProblem"));
%}
NameProblem [[P int*]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode NameProblem"));
%}
INTEGER [[i (*parm)]]
{
noSuchObject(1) ,
aliasProblem(2) ,
invalidAttributeSyntax(3) ,
aliasDereferencingProblem(4)
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode NameProblem"));
%}
UpdateProblem [[P int*]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode UpdateProblem"));
%}
INTEGER [[i (*parm)]]
{
namingViolation(1) ,
objectClassViolation(2) ,
notAllowedOnNonLeaf(3) ,
notAllowedOnRDN(4) ,
entryAlreadyExists(5) ,
affectsMultipleDSAs(6) ,
objectClassModificationProhibited(7)
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode UpdateProblem"));
%}
DirectoryBindArgument [[P struct ds_bind_arg *]]
%{
struct simple_creds usc_s;
struct simple_creds * usc = &(usc_s);
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode DirectoryBindArgument"));
parm->dba_dn = usc->usc_dn = NULLDN;
parm->dba_passwd_len = usc->usc_passwd_len = 0;
parm->dba_auth_type = DBA_AUTH_NONE;
usc->usc_passwd = NULL;
usc->usc_time1 = NULL;
usc->usc_time2 = NULL;
parm->dba_version = DBA_VERSION_V1988;
%}
SET
{
credentials
[0] Credentials [[p parm]]
%{
%}
OPTIONAL ,
versions
[1] Versions [[p &(parm->dba_version)]]
%{
%}
-- DEFAULT v1988
OPTIONAL
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode DirectoryBindArgument"));
%}
DirectoryBindResult [[P struct ds_bind_arg *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode DirectoryBindResult"));
%}
DirectoryBindArgument [[p parm]]
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode DirectoryBindResult"));
%}
ReadArgumentData [[P struct ds_read_arg *]]
%{
struct extension **extp;
struct common_args * ca;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode ReadArgumentData"));
parm->rda_object = NULLDN;
eis_def(&(parm->rda_eis));
ca = &(parm->rda_common);
svc_def(&(ca->ca_servicecontrol));
ca->ca_requestor = NULLDN;
ca->ca_progress.op_resolution_phase = 0;
ca->ca_progress.op_nextrdntoberesolved = 0;
ca->ca_aliased_rdns = CA_NO_ALIASDEREFERENCED;
ca->ca_extensions = NULLEXT;
ca->ca_security = (struct security_parms *) 0;
ca->ca_sig = (struct signature *) 0;
extp = &(ca->ca_extensions);
%}
SET
{
object
[0] Name [[p &(parm->rda_object)]]
%{
%} ,
selection
[1] EntryInformationSelection [[p &(parm->rda_eis)]]
%{
%}
-- DEFAULT {} ,
OPTIONAL ,
[30] ServiceControls [[p &(ca->ca_servicecontrol)]]
%{
%}
-- DEFAULT {} ,
OPTIONAL ,
[29] SecurityParameters [[p &(ca->ca_security)]]
-- DEFAULT {} ,
OPTIONAL ,
requestor
[28] DistinguishedName [[p &(ca->ca_requestor)]]
%{
%}
OPTIONAL ,
[27] OperationProgress [[p &(ca->ca_progress)]]
%{
%}
OPTIONAL ,
aliasedRDNs
[26] INTEGER [[i ca->ca_aliased_rdns]]
OPTIONAL ,
extensions
[25] SET OF
%{
(*extp) = ext_alloc();
%}
Extension [[p (*extp)]]
%{
extp = &((*extp)->ext_next);
%}
%{
(*extp) = NULLEXT;
%}
OPTIONAL
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode ReadArgumentData"));
%}
ReadArgument [[P struct ds_read_arg *]]
%{
struct signature sig;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At decode ReadArgument"));
%}
CHOICE
{
ReadArgumentData [[p parm]] ,
SEQUENCE
{
ReadArgumentData [[p parm]] ,
AlgorithmIdentifier [[p &(sig.alg)]],
BIT STRING [[x (sig.encrypted) $ (sig.n_bits)]]
}
%{
parm->rda_common.ca_sig = (struct signature *)
calloc(1, sizeof(sig));
bcopy((char *)&sig, (char *)parm->rda_common.ca_sig, sizeof(sig));
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode ReadArgument"));
%}
ReadResultData [[P struct ds_read_result *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode ReadResultData"));
parm->rdr_entry.ent_dn = NULLDN;
parm->rdr_entry.ent_attr = NULLATTR;
parm->rdr_entry.ent_iscopy = 0;
parm->rdr_entry.ent_next = NULLENTRYINFO;
parm->rdr_common.cr_requestor = NULLDN;
parm->rdr_common.cr_aliasdereferenced = FALSE;
%}
SET
{
entry
[0] EntryInformation [[p &(parm->rdr_entry)]]
%{
%} ,
[30] SecurityParameters [[p ((struct security_parms **) 0)]]
OPTIONAL ,
performer
[29] DistinguishedName [[p &(parm->rdr_common.cr_requestor)]]
%{
%}
OPTIONAL ,
aliasDereferenced
[28] BOOLEAN [[b parm->rdr_common.cr_aliasdereferenced]]
%{
%}
-- DEFAULT FALSE
OPTIONAL
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode ReadResultData"));
%}
ReadResult [[P struct ds_read_result *]]
%{
struct alg_id alg;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At decode ReadResult"));
%}
CHOICE
{
ReadResultData [[p parm]] ,
SEQUENCE
{
ReadResultData [[p parm]] ,
AlgorithmIdentifier [[p &alg]],
BIT STRING
}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode ReadResult"));
%}
CompareArgumentData [[P struct ds_compare_arg *]]
%{
struct extension **extp;
struct common_args * ca;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode CompareArgumentData"));
parm->cma_object = NULLDN;
parm->cma_purported.ava_type = NULLAttrT;
parm->cma_purported.ava_value = NULLAttrV;
ca = &(parm->cma_common);
svc_def(&(ca->ca_servicecontrol));
ca->ca_requestor = NULLDN;
ca->ca_progress.op_resolution_phase = 0;
ca->ca_progress.op_nextrdntoberesolved = 0;
ca->ca_aliased_rdns = CA_NO_ALIASDEREFERENCED;
ca->ca_extensions = NULLEXT;
ca->ca_security = (struct security_parms *) 0;
ca->ca_sig = (struct signature *) 0;
extp = &(ca->ca_extensions);
%}
SET
{
object
[0] Name [[p &(parm->cma_object)]]
%{
%} ,
purported
[1] AttributeValueAssertion [[p &(parm->cma_purported)]]
%{
%} ,
[30] ServiceControls [[p &(ca->ca_servicecontrol)]]
%{
%}
-- DEFAULT {} ,
OPTIONAL ,
[29] SecurityParameters [[p &(ca->ca_security)]]
-- DEFAULT {} ,
OPTIONAL ,
requestor
[28] DistinguishedName [[p &(ca->ca_requestor)]]
%{
%}
OPTIONAL ,
[27] OperationProgress [[p &(ca->ca_progress)]]
%{
%}
OPTIONAL ,
aliasedRDNs
[26] INTEGER [[i ca->ca_aliased_rdns]]
OPTIONAL ,
extensions
[25] SET OF
%{
(*extp) = ext_alloc();
%}
Extension [[p (*extp)]]
%{
extp = &((*extp)->ext_next);
%}
%{
(*extp) = NULLEXT;
%}
OPTIONAL
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode CompareArgumentData"));
%}
CompareArgument [[P struct ds_compare_arg *]]
%{
struct signature sig;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At decode CompareArgument"));
%}
CHOICE
{
CompareArgumentData [[p parm]] ,
SEQUENCE
{
CompareArgumentData [[p parm]] ,
AlgorithmIdentifier [[p &(sig.alg)]],
BIT STRING [[x (sig.encrypted) $ (sig.n_bits)]]
}
%{
parm->cma_common.ca_sig = (struct signature *)
calloc(1, sizeof(sig));
bcopy((char*)&sig, (char*)parm->cma_common.ca_sig, sizeof(sig));
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode CompareArgument"));
%}
CompareResultData [[P struct ds_compare_result *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode CompareResultData"));
parm->cmr_object = NULLDN;
parm->cmr_matched = 0;
parm->cmr_iscopy = E_DATA_MASTER;
parm->cmr_common.cr_requestor = NULLDN;
parm->cmr_common.cr_aliasdereferenced = FALSE;
%}
SET
{
DistinguishedName [[p &(parm->cmr_object)]]
%{
%}
OPTIONAL ,
matched
[0] BOOLEAN [[b parm->cmr_matched]]
%{
%} ,
fromEntry
[1] BOOLEAN [[b parm->cmr_iscopy]]
%{
%}
-- DEFAULT TRUE ,
OPTIONAL ,
[30] SecurityParameters [[p ((struct security_parms **) 0)]]
OPTIONAL ,
performer
[29] DistinguishedName [[p &(parm->cmr_common.cr_requestor)]]
%{
%}
OPTIONAL ,
aliasDereferenced
[28] BOOLEAN [[b parm->cmr_common.cr_aliasdereferenced]]
%{
%}
-- DEFAULT FALSE
OPTIONAL
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode CompareResultData"));
%}
CompareResult [[P struct ds_compare_result *]]
%{
struct alg_id alg;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At decode CompareResult"));
%}
CHOICE
{
CompareResultData [[p parm]] ,
SEQUENCE
{
CompareResultData [[p parm]] ,
AlgorithmIdentifier [[p &alg]],
BIT STRING
}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode CompareResult"));
%}
AbandonArgument [[P struct ds_abandon_arg *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode AbandonArgument"));
parm->aba_invokeid = 0;
%}
SEQUENCE
{
invokeID
[0] InvokeID [[p &(parm->aba_invokeid)]]
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode AbandonArgument"));
%}
AbandonResult ::= NULL
ListArgumentData [[P struct ds_list_arg *]]
%{
struct extension **extp;
struct common_args * ca;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode ListArgumentData"));
parm->lsa_object = NULLDN;
ca = &(parm->lsa_common);
svc_def(&(ca->ca_servicecontrol));
ca->ca_requestor = NULLDN;
ca->ca_progress.op_resolution_phase = 0;
ca->ca_progress.op_nextrdntoberesolved = 0;
ca->ca_aliased_rdns = CA_NO_ALIASDEREFERENCED;
ca->ca_extensions = NULLEXT;
ca->ca_security = (struct security_parms *) 0;
ca->ca_sig = (struct signature *) 0;
extp = &(ca->ca_extensions);
%}
SET
{
object
[0] Name [[p &(parm->lsa_object)]]
%{
%} ,
[30] ServiceControls [[p &(parm->lsa_common.ca_servicecontrol)]]
%{
%}
-- DEFAULT {} ,
OPTIONAL ,
[29] SecurityParameters [[p &(ca->ca_security)]]
-- DEFAULT {} ,
OPTIONAL ,
requestor
[28] DistinguishedName [[p &(ca->ca_requestor)]]
%{
%}
OPTIONAL ,
[27] OperationProgress [[p &(ca->ca_progress)]]
%{
%}
OPTIONAL ,
aliasedRDNs
[26] INTEGER [[i ca->ca_aliased_rdns]]
OPTIONAL ,
extensions
[25] SET OF
%{
(*extp) = ext_alloc();
%}
Extension [[p (*extp)]]
%{
extp = &((*extp)->ext_next);
%}
%{
(*extp) = NULLEXT;
%}
OPTIONAL
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode ListArgumentData"));
%}
ListArgument [[P struct ds_list_arg *]]
%{
struct signature sig;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At decode ListArgument"));
%}
CHOICE
{
ListArgumentData [[p parm]] ,
SEQUENCE
{
ListArgumentData [[p parm]] ,
AlgorithmIdentifier [[p &(sig.alg)]],
BIT STRING [[x (sig.encrypted) $ (sig.n_bits)]]
}
%{
parm->lsa_common.ca_sig = (struct signature *)
calloc(1, sizeof(sig));
bcopy((char*)&sig, (char*)parm->lsa_common.ca_sig, sizeof(sig));
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode ListArgument"));
%}
ListResultData [[P struct ds_list_result *]]
%{
POQ poq_next_s;
POQ * poq_next = &(poq_next_s);
struct subordinate **sub_next;
struct subordinate **subp;
struct continuation_ref **crp;
struct ds_list_result temp_list;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode ListResultData"));
parm->lsr_object = NULLDN;
parm->lsr_subordinates = NULLSUBORD;
parm->lsr_limitproblem = LSR_NOLIMITPROBLEM;
parm->lsr_cr = NULLCONTINUATIONREF;
parm->lsr_common.cr_requestor = NULLDN;
parm->lsr_common.cr_aliasdereferenced = FALSE;
sub_next = &(parm->lsr_subordinates);
%}
CHOICE
{
listInfo
SET
{
DistinguishedName [[p &(parm->lsr_object)]]
%{
%}
OPTIONAL ,
subordinates
[1] SET OF
%{
(*sub_next) = (struct subordinate *) smalloc(sizeof(struct subordinate));
(*sub_next)->sub_rdn = NULLRDN;
(*sub_next)->sub_aliasentry = FALSE;
(*sub_next)->sub_copy = E_DATA_MASTER;
%}
SEQUENCE
{
RelativeDistinguishedName [[p &((*sub_next)->sub_rdn)]]
%{
%} ,
aliasEntry
[0] BOOLEAN [[b (*sub_next)->sub_aliasentry]]
%{
%}
-- DEFAULT FALSE ,
OPTIONAL ,
fromEntry
[1] BOOLEAN [[b (*sub_next)->sub_copy]]
%{
%}
-- DEFAULT TRUE
OPTIONAL
}
%{
sub_next = &((*sub_next)->sub_next);
%}
%{
(*sub_next) = NULLSUBORD;
%} ,
partialOutcomeQualifier
[2] PartialOutcomeQualifier [[p poq_next]]
%{
parm->lsr_limitproblem = poq_next->poq_limitproblem;
parm->lsr_cr = poq_next->poq_cref;
%}
OPTIONAL ,
[30] SecurityParameters [[p ((struct security_parms **) 0)]]
OPTIONAL ,
performer
[29] DistinguishedName [[p &(parm->lsr_common.cr_requestor)]]
%{
%}
OPTIONAL ,
aliasDereferenced
[28] BOOLEAN [[b parm->lsr_common.cr_aliasdereferenced]]
%{
%}
-- DEFAULT FALSE
OPTIONAL
}
%{
%} ,
uncorrelatedListInfo
[0] SET OF
%{
%}
ListResult [[p &(temp_list)]]
%{
LLOG(log_dsap, LLOG_EXCEPTIONS, ("Uncorrelated ListInfo!"));
if(parm->lsr_object == NULLDN)
{
parm->lsr_object = dn_cpy(temp_list.lsr_object);
parm->lsr_common.cr_requestor = dn_cpy(temp_list.lsr_common.cr_requestor);
parm->lsr_common.cr_aliasdereferenced = temp_list.lsr_common.cr_aliasdereferenced;
}
dn_free(temp_list.lsr_object);
dn_free(temp_list.lsr_common.cr_requestor);
if(parm->lsr_limitproblem == LSR_NOLIMITPROBLEM)
{
parm->lsr_limitproblem = temp_list.lsr_limitproblem;
}
if(temp_list.lsr_cr != NULLCONTINUATIONREF)
{
for(crp = &(parm->lsr_cr); (*crp) != NULLCONTINUATIONREF; crp = &((*crp)->cr_next));
(*crp) = temp_list.lsr_cr;
temp_list.lsr_cr = NULLCONTINUATIONREF;
}
if(temp_list.lsr_subordinates != NULLSUBORD)
{
for(subp = &(parm->lsr_subordinates); (*subp) != NULLSUBORD; subp = &((*subp)->sub_next));
(*subp) = temp_list.lsr_subordinates;
temp_list.lsr_subordinates = NULLSUBORD;
}
%}
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode ListResultData"));
%}
ListResult [[P struct ds_list_result *]]
%{
struct alg_id alg;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At decode ListResult"));
%}
CHOICE
{
ListResultData [[p parm]] ,
SEQUENCE
{
ListResultData [[p parm]] ,
AlgorithmIdentifier [[p &alg]],
BIT STRING
}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode ListResult"));
%}
SearchArgumentData [[P struct ds_search_arg *]]
%{
struct extension **extp;
struct common_args * ca;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode SearchArgumentData"));
parm->sra_baseobject = NULLDN;
parm->sra_subset = SRA_BASEOBJECT;
parm->sra_filter = NULLFILTER;
parm->sra_searchaliases = TRUE;
eis_def(&(parm->sra_eis));
ca = &(parm->sra_common);
svc_def(&(ca->ca_servicecontrol));
ca->ca_requestor = NULLDN;
ca->ca_progress.op_resolution_phase = 0;
ca->ca_progress.op_nextrdntoberesolved = 0;
ca->ca_aliased_rdns = CA_NO_ALIASDEREFERENCED;
ca->ca_extensions = NULLEXT;
ca->ca_security = (struct security_parms *) 0;
ca->ca_sig = (struct signature *) 0;
extp = &(ca->ca_extensions);
%}
SET
{
baseObject
[0] Name [[p &(parm->sra_baseobject)]]
%{
%} ,
subset
[1] INTEGER [[i parm->sra_subset]]
{
baseObject(0) ,
oneLevel(1) ,
wholeSubtree(2)
}
%{
%}
-- DEFAULT baseObject ,
OPTIONAL ,
filter
%{
parm->sra_filter = filter_alloc();
%}
[2] Filter [[p parm->sra_filter]]
%{
%}
-- DEFAULT and {} ,
OPTIONAL ,
searchAliases
[3] BOOLEAN [[b parm->sra_searchaliases]]
-- DEFAULT TRUE ,
OPTIONAL ,
selection
[4] EntryInformationSelection [[p &(parm->sra_eis)]]
%{
%}
-- DEFAULT {} ,
OPTIONAL ,
[30] ServiceControls [[p &(ca->ca_servicecontrol)]]
%{
%}
-- DEFAULT {} ,
OPTIONAL ,
[29] SecurityParameters [[p &(ca->ca_security)]]
-- DEFAULT {} ,
OPTIONAL ,
requestor
[28] DistinguishedName [[p &(ca->ca_requestor)]]
%{
%}
OPTIONAL ,
[27] OperationProgress [[p &(ca->ca_progress)]]
%{
%}
OPTIONAL ,
aliasedRDNs
[26] INTEGER [[i ca->ca_aliased_rdns]]
OPTIONAL ,
extensions
[25] SET OF
%{
(*extp) = ext_alloc();
%}
Extension [[p (*extp)]]
%{
extp = &((*extp)->ext_next);
%}
%{
(*extp) = NULLEXT;
%}
OPTIONAL
}
%{
if(parm->sra_filter == NULLFILTER)
{
parm->sra_filter = filter_alloc();
flt_def(&(parm->sra_filter));
}
DLOG(log_dsap, LLOG_TRACE, ("Done decode SearchArgumentData"));
%}
SearchArgument [[P struct ds_search_arg *]]
%{
struct signature sig;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At decode SearchArgument"));
%}
CHOICE
{
SearchArgumentData [[p parm]] ,
SEQUENCE
{
SearchArgumentData [[p parm]] ,
AlgorithmIdentifier [[p &(sig.alg)]],
BIT STRING [[x (sig.encrypted) $ (sig.n_bits)]]
}
%{
parm->sra_common.ca_sig = (struct signature *)
calloc(1, sizeof(sig));
bcopy((char*)&sig, (char*)parm->sra_common.ca_sig, sizeof(sig));
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode SearchArgument"));
%}
SearchResultData [[P struct ds_search_result *]]
%{
struct ds_search_result **srrp;
EntryInfo **ent_next;
POQ poq_next_s;
POQ * poq_next = &(poq_next_s);
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode SearchResultData"));
%}
CHOICE
{
searchInfo
%{
parm->srr_correlated = TRUE;
parm->srr_un.srr_unit = (struct ds_search_unit *) malloc(sizeof(struct ds_search_unit));
parm->CSR_object = NULLDN;
parm->CSR_entries = NULLENTRYINFO;
parm->CSR_limitproblem = LSR_NOLIMITPROBLEM;
parm->CSR_cr = NULLCONTINUATIONREF;
parm->CSR_common.cr_requestor = NULLDN;
parm->CSR_common.cr_aliasdereferenced = FALSE;
ent_next = &(parm->CSR_entries);
%}
SET
{
DistinguishedName [[p &(parm->CSR_object)]]
%{
%}
OPTIONAL ,
entries
[0] SET OF
%{
(*ent_next) = entryinfo_alloc();
%}
EntryInformation [[p (*ent_next)]]
%{
ent_next = &((*ent_next)->ent_next);
%}
%{
(*ent_next) = NULLENTRYINFO;
%} ,
partialOutcomeQualifier
[2] PartialOutcomeQualifier [[p poq_next]]
%{
parm->CSR_limitproblem = poq_next->poq_limitproblem;
parm->CSR_cr = poq_next->poq_cref;
%}
OPTIONAL ,
[30] SecurityParameters [[p ((struct security_parms **) 0)]]
OPTIONAL ,
performer
[29] DistinguishedName [[p &(parm->CSR_common.cr_requestor)]]
%{
%}
OPTIONAL ,
aliasDereferenced
[28] BOOLEAN [[b parm->CSR_common.cr_aliasdereferenced]]
%{
%}
-- DEFAULT FALSE
OPTIONAL
}
%{
%} ,
uncorrelatedSearchInfo
%{
parm->srr_correlated = FALSE;
srrp = &(parm->srr_un.srr_parts);
%}
[0] SET OF
%{
(*srrp) = (struct ds_search_result *) malloc(sizeof(struct ds_search_result));
%}
SearchResult [[p (*srrp)]]
%{
srrp = &((*srrp)->srr_next);
%}
%{
(*srrp)->srr_next = NULLSRR;
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode SearchResultData"));
%}
SearchResult [[P struct ds_search_result *]]
%{
struct alg_id alg;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At decode SearchResult"));
%}
CHOICE
{
SearchResultData [[p parm]] ,
SEQUENCE
{
SearchResultData [[p parm]] ,
AlgorithmIdentifier [[p &alg]],
BIT STRING
}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode SearchResult"));
%}
AddEntryArgumentData [[P struct ds_addentry_arg *]]
%{
struct extension **extp;
struct common_args * ca;
Attr_Sequence attr_tmp;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode AddEntryArgumentData"));
parm->ada_object = NULLDN;
parm->ada_entry = NULLATTR;
ca = &(parm->ada_common);
svc_def(&(ca->ca_servicecontrol));
ca->ca_requestor = NULLDN;
ca->ca_progress.op_resolution_phase = 0;
ca->ca_progress.op_nextrdntoberesolved = 0;
ca->ca_aliased_rdns = CA_NO_ALIASDEREFERENCED;
ca->ca_extensions = NULLEXT;
extp = &(ca->ca_extensions);
ca->ca_security = (struct security_parms *) 0;
ca->ca_sig = (struct signature *) 0;
%}
SET
{
object
[0] DistinguishedName [[p &(parm->ada_object)]]
%{
%} ,
entry
[1] SET OF
%{
attr_tmp = as_comp_alloc();
attr_tmp->attr_value = NULLAV;
attr_tmp->attr_acl = NULLACL_INFO;
attr_tmp->attr_link = NULLATTR;
%}
Attribute [[p attr_tmp]]
%{
parm->ada_entry = as_merge(parm->ada_entry, attr_tmp);
%} ,
[30] ServiceControls [[p &(ca->ca_servicecontrol)]]
%{
%}
-- DEFAULT {} ,
OPTIONAL ,
[29] SecurityParameters [[p &(ca->ca_security)]]
-- DEFAULT {} ,
OPTIONAL ,
requestor
[28] DistinguishedName [[p &(ca->ca_requestor)]]
%{
%}
OPTIONAL ,
[27] OperationProgress [[p &(ca->ca_progress)]]
%{
%}
OPTIONAL ,
aliasedRDNs
[26] INTEGER [[i ca->ca_aliased_rdns]]
OPTIONAL ,
extensions
[25] SET OF
%{
(*extp) = ext_alloc();
%}
Extension [[p (*extp)]]
%{
extp = &((*extp)->ext_next);
%}
%{
(*extp) = NULLEXT;
%}
OPTIONAL
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode AddEntryArgumentData"));
%}
AddEntryArgument [[P struct ds_addentry_arg *]]
%{
struct signature sig;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At decode AddEntryArgument"));
%}
CHOICE
{
AddEntryArgumentData [[p parm]] ,
SEQUENCE
{
AddEntryArgumentData [[p parm]] ,
AlgorithmIdentifier [[p &(sig.alg)]],
BIT STRING [[x (sig.encrypted) $ (sig.n_bits)]]
}
%{
parm->ada_common.ca_sig = (struct signature *)
calloc(1, sizeof(sig));
bcopy((char*)&sig, (char*)parm->ada_common.ca_sig, sizeof(sig));
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode AddEntryArgument"));
%}
AddEntryResult ::= NULL
RemoveEntryArgumentData [[P struct ds_removeentry_arg *]]
%{
struct extension **extp;
struct common_args * ca;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode RemoveEntryArgumentData"));
ca = &(parm->rma_common);
svc_def(&(ca->ca_servicecontrol));
ca->ca_requestor = NULLDN;
ca->ca_progress.op_resolution_phase = 0;
ca->ca_progress.op_nextrdntoberesolved = 0;
ca->ca_aliased_rdns = CA_NO_ALIASDEREFERENCED;
ca->ca_extensions = NULLEXT;
ca->ca_security = (struct security_parms *) 0;
ca->ca_sig = (struct signature *) 0;
extp = &(ca->ca_extensions);
%}
SET
{
object
[0] DistinguishedName [[p &(parm->rma_object)]]
%{
%} ,
[30] ServiceControls [[p &(ca->ca_servicecontrol)]]
%{
%}
-- DEFAULT {} ,
OPTIONAL ,
[29] SecurityParameters [[p &(ca->ca_security)]]
-- DEFAULT {} ,
OPTIONAL ,
requestor
[28] DistinguishedName [[p &(ca->ca_requestor)]]
%{
%}
OPTIONAL ,
[27] OperationProgress [[p &(ca->ca_progress)]]
%{
%}
OPTIONAL ,
aliasedRDNs
[26] INTEGER [[i ca->ca_aliased_rdns]]
OPTIONAL ,
extensions
[25] SET OF
%{
(*extp) = ext_alloc();
%}
Extension [[p (*extp)]]
%{
extp = &((*extp)->ext_next);
%}
%{
(*extp) = NULLEXT;
%}
OPTIONAL
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode RemoveEntryArgumentData"));
%}
RemoveEntryArgument [[P struct ds_removeentry_arg *]]
%{
struct signature sig;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At decode RemoveEntryArgument"));
%}
CHOICE
{
RemoveEntryArgumentData [[p parm]] ,
SEQUENCE
{
RemoveEntryArgumentData [[p parm]] ,
AlgorithmIdentifier [[p &(sig.alg)]],
BIT STRING [[x (sig.encrypted) $ (sig.n_bits)]]
}
%{
parm->rma_common.ca_sig = (struct signature *)
calloc(1, sizeof(sig));
bcopy((char*)&sig, (char*)parm->rma_common.ca_sig, sizeof(sig));
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode RemoveEntryArgument"));
%}
RemoveEntryResult ::= NULL
ModifyEntryArgumentData [[P struct ds_modifyentry_arg *]]
%{
struct extension **extp;
struct common_args * ca;
struct entrymod **em_next;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode ModifyEntryArgumentData"));
parm->mea_object = NULLDN;
parm->mea_changes = NULLMOD;
em_next = &(parm->mea_changes);
ca = &(parm->mea_common);
svc_def(&(ca->ca_servicecontrol));
ca->ca_requestor = NULLDN;
ca->ca_progress.op_resolution_phase = 0;
ca->ca_progress.op_nextrdntoberesolved = 0;
ca->ca_aliased_rdns = CA_NO_ALIASDEREFERENCED;
ca->ca_extensions = NULLEXT;
ca->ca_security = (struct security_parms *) 0;
ca->ca_sig = (struct signature *) 0;
extp = &(ca->ca_extensions);
%}
SET
{
object
[0] DistinguishedName [[p &(parm->mea_object)]]
%{
%} ,
changes
[1] SEQUENCE OF
%{
(*em_next) = em_alloc();
%}
EntryModification [[p (*em_next)]]
%{
em_next = &((*em_next)->em_next);
%}
%{
(*em_next) = NULLMOD;
%} ,
[30] ServiceControls [[p &(ca->ca_servicecontrol)]]
%{
%}
-- DEFAULT {} ,
OPTIONAL ,
[29] SecurityParameters [[p &(ca->ca_security)]]
-- DEFAULT {} ,
OPTIONAL ,
requestor
[28] DistinguishedName [[p &(ca->ca_requestor)]]
%{
%}
OPTIONAL ,
[27] OperationProgress [[p &(ca->ca_progress)]]
%{
%}
OPTIONAL ,
aliasedRDNs
[26] INTEGER [[i ca->ca_aliased_rdns]]
OPTIONAL ,
extensions
[25] SET OF
%{
(*extp) = ext_alloc();
%}
Extension [[p (*extp)]]
%{
extp = &((*extp)->ext_next);
%}
%{
(*extp) = NULLEXT;
%}
OPTIONAL
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode ModifyEntryArgumentData"));
%}
ModifyEntryArgument [[P struct ds_modifyentry_arg *]]
%{
struct signature sig;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At decode ModifyEntryArgument"));
%}
CHOICE
{
ModifyEntryArgumentData [[p parm]] ,
SEQUENCE
{
ModifyEntryArgumentData [[p parm]] ,
AlgorithmIdentifier [[p &(sig.alg)]],
BIT STRING [[x (sig.encrypted) $ (sig.n_bits)]]
}
%{
parm->mea_common.ca_sig = (struct signature *)
calloc(1, sizeof(struct signature));
bcopy((char*)&sig, (char*)parm->mea_common.ca_sig, sizeof(sig));
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode ModifyEntryArgument"));
%}
ModifyEntryResult ::= NULL
ModifyRDNArgumentData [[P struct ds_modifyrdn_arg *]]
%{
struct extension **extp;
struct common_args * ca;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode ModifyRDNArgumentData"));
parm->mra_object = NULLDN;
parm->mra_newrdn = NULLRDN;
parm->deleterdn = FALSE;
ca = &(parm->mra_common);
svc_def(&(ca->ca_servicecontrol));
ca->ca_requestor = NULLDN;
ca->ca_progress.op_resolution_phase = 0;
ca->ca_progress.op_nextrdntoberesolved = 0;
ca->ca_aliased_rdns = CA_NO_ALIASDEREFERENCED;
ca->ca_security = (struct security_parms *) 0;
ca->ca_sig = (struct signature *) 0;
ca->ca_extensions = NULLEXT;
extp = &(ca->ca_extensions);
%}
SET
{
object
[0] DistinguishedName [[p &(parm->mra_object)]]
%{
%} ,
newRDN
[1] RelativeDistinguishedName [[p &(parm->mra_newrdn)]]
%{
%} ,
deleteRDN
[2] BOOLEAN [[b parm->deleterdn]]
%{
%}
-- DEFAULT FALSE ,
OPTIONAL ,
[30] ServiceControls [[p &(ca->ca_servicecontrol)]]
%{
%}
-- DEFAULT {} ,
OPTIONAL ,
[29] SecurityParameters [[p &(ca->ca_security)]]
-- DEFAULT {} ,
OPTIONAL ,
requestor
[28] DistinguishedName [[p &(ca->ca_requestor)]]
%{
%}
OPTIONAL ,
[27] OperationProgress [[p &(ca->ca_progress)]]
%{
%}
OPTIONAL ,
aliasedRDNs
[26] INTEGER [[i ca->ca_aliased_rdns]]
OPTIONAL ,
extensions
[25] SET OF
%{
(*extp) = ext_alloc();
%}
Extension [[p (*extp)]]
%{
extp = &((*extp)->ext_next);
%}
%{
(*extp) = NULLEXT;
%}
OPTIONAL
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode ModifyRDNArgumentData"));
%}
ModifyRDNArgument [[P struct ds_modifyrdn_arg *]]
%{
struct signature sig;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("At decode ModifyRDNArgument"));
%}
CHOICE
{
ModifyRDNArgumentData [[p parm]] ,
SEQUENCE
{
ModifyRDNArgumentData [[p parm]] ,
AlgorithmIdentifier [[p &(sig.alg)]],
BIT STRING [[x (sig.encrypted) $ (sig.n_bits)]]
}
%{
parm->mra_common.ca_sig = (struct signature *)
calloc(1, sizeof(sig));
bcopy((char *)&sig, (char *)parm->mra_common.ca_sig, sizeof(sig));
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode ModifyRDNArgument"));
%}
ModifyRDNResult ::= NULL
DirectoryBindError [[P struct ds_bind_error *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode DirectoryBindError"));
parm->dbe_version = DBA_VERSION_V1988;
%}
SET
{
versions
[0] Versions [[p &(parm->dbe_version)]]
%{
%}
-- DEFAULT v1988 ,
OPTIONAL ,
CHOICE
{
serviceError
[1] ServiceProblem [[p &(parm->dbe_value)]]
%{
parm->dbe_type = DBE_TYPE_SERVICE;
%} ,
securityError
[2] SecurityProblem [[p &(parm->dbe_value)]]
%{
parm->dbe_type = DBE_TYPE_SECURITY;
%}
}
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode DirectoryBindError"));
%}
AbandonFailedParm [[P struct DSE_abandon_fail *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode AbandonFailedParm"));
parm->DSE_ab_problem = 0;
parm->DSE_ab_invokeid = 0;
%}
SET
%{
%}
{
problem
[0] AbandonProblem [[p &(parm->DSE_ab_problem)]]
%{
%} ,
operation
[1] InvokeID [[p &(parm->DSE_ab_invokeid)]]
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode AbandonFailedParm"));
%}
AttributeErrorParm [[P struct DSE_attribute *]]
%{
struct DSE_at_problem atp_next;
struct DSE_at_problem *atp;
int not_first_problem = FALSE;
AttributeValue av;
AttributeType at;
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode AttributeErrorParm"));
av = AttrV_alloc();
at = AttrT_alloc();
parm->DSE_at_name = NULLDN;
parm->DSE_at_plist.DSE_at_what = 0;
parm->DSE_at_plist.DSE_at_type = NULLAttrT;
parm->DSE_at_plist.DSE_at_value = NULLAttrV;
parm->DSE_at_plist.dse_at_next = DSE_AT_NOPROBLEM;
atp = &(parm->DSE_at_plist);
%}
SET
%{
%}
{
object
[0] Name [[p &(parm->DSE_at_name)]]
%{
%} ,
problems
[1] SET OF
%{
%}
SEQUENCE
%{
atp_next.DSE_at_value = NULLAttrV;
atp_next.DSE_at_type = NULLAttrT;
%}
{
problem
[0] AttributeProblem [[p &(atp_next.DSE_at_what)]]
%{
%} ,
type
[1] AttributeType [[p at]]
%{
atp_next.DSE_at_type = at;
at = AttrT_alloc ();
%} ,
value
[2] AttributeValue [[p av]]
%{
atp_next.DSE_at_value = av;
av = AttrV_alloc ();
%}
OPTIONAL
}
%{
if(not_first_problem)
{
atp->dse_at_next = (struct DSE_at_problem *) smalloc(sizeof(struct DSE_at_problem));
atp = atp->dse_at_next;
}
atp->DSE_at_what = atp_next.DSE_at_what;
atp->DSE_at_type = atp_next.DSE_at_type;
atp->DSE_at_value = atp_next.DSE_at_value;
not_first_problem = TRUE;
%}
%{
atp->dse_at_next = DSE_AT_NOPROBLEM;
%}
}
%{
free ((char*) av);
free ((char*) at);
DLOG(log_dsap, LLOG_TRACE, ("Done decode AttributeErrorParm"));
%}
NameErrorParm [[P struct DSE_name *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode NameErrorParm"));
parm->DSE_na_problem = 0;
parm->DSE_na_matched = NULLDN;
%}
SET
%{
%}
{
problem
[0] NameProblem [[p &(parm->DSE_na_problem)]]
%{
%} ,
matched
[1] Name [[p &(parm->DSE_na_matched)]]
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode NameErrorParm"));
%}
ReferralParm [[P struct DSE_referral *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode ReferralParm"));
parm->DSE_ref_prefix = NULLDN;
parm->DSE_ref_candidates = (ContinuationRef) smalloc(sizeof(continuation_ref));
%}
SET
%{
%}
{
candidate
[0] ContinuationReference [[p parm->DSE_ref_candidates]]
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode ReferralParm"));
%}
SecurityErrorParm [[P struct DSE_security *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode SecurityErrorParm"));
parm->DSE_sc_problem = 0;
%}
SET
%{
%}
{
problem
[0] SecurityProblem [[p &(parm->DSE_sc_problem)]]
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode SecurityErrorParm"));
%}
ServiceErrorParm [[P struct DSE_service *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode ServiceErrorParm"));
parm->DSE_sv_problem = 0;
%}
SET
%{
%}
{
problem
[0] ServiceProblem [[p &(parm->DSE_sv_problem)]]
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode ServiceErrorParm"));
%}
UpdateErrorParm [[P struct DSE_update *]]
%{
%}
::=
%{
DLOG(log_dsap, LLOG_TRACE, ("About to decode UpdateErrorParm"));
parm->DSE_up_problem = 0;
%}
SET
%{
%}
{
problem
[0] UpdateProblem [[p &(parm->DSE_up_problem)]]
%{
%}
}
%{
DLOG(log_dsap, LLOG_TRACE, ("Done decode UpdateErrorParm"));
%}
END