⟦3acb28c09⟧

TextFile

-- das-enc.py - manually augmented DirectoryAbstractService module

-- $Header: /f/osi/dsap/x500as/RCS/das-enc.py,v 7.0 89/11/23 21:50:14 mrose Rel $
--
--
-- $Log:	das-enc.py,v $
-- Revision 7.0  89/11/23  21:50:14  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"

extern  LLog    * log_dsap;

#define encode_UNIV_UTCTime build_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)
			};

ENCODER encode

SimpleCredentials [[P struct ds_bind_arg *]]
%{
%}
        ::=
        %{
        DLOG(log_dsap, LLOG_TRACE, ("About to encode SimpleCredentials (DAS)"));
        %}
        SEQUENCE
        {
        name
                [0] DistinguishedName [[p parm->dba_dn]]
                %{
                %} ,
        validity
                [1] SET
                %{
                %}
                {
                time1
                        [0] UTCTime [[s parm -> dba_time1]]
                        %{
                        %} OPTIONAL <<parm -> dba_time1>> ,
                time2
                        [1] UTCTime [[s parm -> dba_time2]]
                        %{
                        %} OPTIONAL <<parm -> dba_time2>> ,
                random1
                        [2] BIT STRING [[x parm->dba_r1.value $ parm->dba_r1.n_bits]]
                        %{
                        %} OPTIONAL <<parm->dba_r1.value != NULLCP>> ,
                random2
                        [3] BIT STRING [[x parm->dba_r2.value $ parm->dba_r2.n_bits]]
                        %{
                        %} OPTIONAL <<parm->dba_r2.value != NULLCP>>
                }
                %{
                %} OPTIONAL <<parm -> dba_auth_type > DBA_AUTH_SIMPLE>> ,
        password
                [2] OCTET STRING [[o parm->dba_passwd $ parm->dba_passwd_len]]
                %{
                %}
                    OPTIONAL <<parm->dba_auth_type != DBA_AUTH_NONE>>
        }
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode SimpleCredentials (DAS)"));
        %}

TokenToSign [[P struct ds_bind_arg *]]
%{
%}
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode TokenToSign (DAS)"));
        %}
	SEQUENCE
	{
	algorithm
		[0] AlgorithmIdentifier [[p &(parm->dba_sig->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 encode TokenToSign (DAS)"));
        %}

Token [[P struct ds_bind_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode Token (DAS)"));
        %}
	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 encode Token (DAS)"));
        %}

StrongCredentials [[P struct ds_bind_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode StrongCredentials (DAS)"));
        %}
	SET
	{
	certificationPath
		[0] CertificationPath [[p parm->dba_cpath]]
		    OPTIONAL <<parm->dba_cpath>>,
	bindToken
		[1] Token [[p parm]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode StrongCredentials (DAS)"));
        %}

Credentials [[P struct ds_bind_arg *]]
%{
%}
        ::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode Credentials (DAS)"));
        %}
        CHOICE
        <<(parm->dba_auth_type == DBA_AUTH_STRONG)?2:1>>
        {
        simple
                [0] SimpleCredentials [[p parm]]
                %{
                %} ,
	strong
	        [1] StrongCredentials [[p parm]]
		%{
		%} ,
	externalProcedure
		[2] EXTERNAL
        }
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode Credentials (DAS)"));
        %}

Versions [[P int]]
%{
        int     ver_len = 1;
        char    *ver_bits = int2strb(parm,ver_len);
%}
        ::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode Versions (DAS)"));
        %}
        BIT STRING [[x ver_bits $ ver_len]]
        {
        v1988(0)
        }
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode Versions (DAS)"));
        %}

SecurityProblem [[P int]]
%{
%}
        ::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode SecurityProblem (DAS)"));
        %}
        INTEGER [[i parm]]
        {
        inappropriateAuthentication(1) ,
        invalidCredentials(2) ,
        insufficientAccessRights(3) ,
        invalidSignature(4) ,
        protectionRequired(5) ,
	noInformation(6)
        }
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode SecurityProblem (DAS)"));
        %}

ServiceProblem [[P int]]
%{
%}
        ::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ServiceProblem (DAS)"));
        %}
        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 (DAS)"));
        %}

EntryInformationSelection [[P struct entryinfoselection *]]
%{
        Attr_Sequence   attr_temp;
%}
        ::=
        %{
        DLOG(log_dsap, LLOG_TRACE, ("About to encode EntryInformationSelection (DAS)"));
        %}
        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 (DAS)"));
        %}

ServiceControls [[P struct svccontrol *]]
%{
        int     opt_len = 5;
        char    *opt_bits;
%}
        ::=
        %{
        DLOG(log_dsap, LLOG_TRACE, ("About to encode ServiceControls (DAS)"));
                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 (DAS)"));
        %}

ProtectionRequest [[P int]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode ProtectionRequest (DAS)"));
        %}
	INTEGER [[i parm]]
	{
	none (0) ,
	signed (1)
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode ProtectionRequest (DAS)"));
        %}

SecurityParameters [[P struct security_parms *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode SecurityParameters (DAS)"));
        %}
	SET
	{
	certificationPath
		[0] CertificationPath [[p parm->sp_path]]
		    OPTIONAL <<parm->sp_path>> ,
	name
		[1] DistinguishedName [[p parm->sp_name]]
		    OPTIONAL <<parm->sp_name>> ,
	time
		[2] UTCTime [[s parm->sp_time]]
		    OPTIONAL <<parm->sp_time>> ,
	random
		[3] BIT STRING [[x parm->sp_random->value $ parm->sp_random->n_bits]]
		    OPTIONAL <<parm->sp_random>> ,
	target
		[4] ProtectionRequest [[p ((int) parm->sp_target)]]
		    OPTIONAL <<parm->sp_target != '\0'>>
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode SecurityParameters (DAS)"));
        %}

Extension [[P struct extension *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode Extension (DAS)"));
        %}
	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 (DAS)"));
        %}

EntryInformation [[P struct entrystruct *]]
%{
        Attr_Sequence   attr_temp;
%}
        ::=
        %{
        DLOG(log_dsap, LLOG_TRACE, ("About to encode EntryInformation (DAS)"));
        %}
        SEQUENCE
        {
                DistinguishedName [[p parm->ent_dn]]
                %{
                %} ,
        fromEntry
                BOOLEAN [[b (parm->ent_iscopy == E_DATA_MASTER)]]
                %{
                %}
                    -- DEFAULT TRUE <<parm->ent_iscopy != E_DATA_MASTER>> ,
                    OPTIONAL <<parm->ent_iscopy != E_DATA_MASTER>> ,
                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 (DAS)"));
        %}

LimitProblem [[P int]]
%{
%}
        ::=
        %{
        DLOG(log_dsap, LLOG_TRACE, ("About to encode LimitProblem (DAS)"));
        %}
        INTEGER [[i parm]]
        {
        timeLimitExceeded(0) ,
        sizeLimitExceeded(1) ,
        administrativeLimitExceeded(2)
        }
        %{
        DLOG(log_dsap, LLOG_TRACE, ("Done encode LimitProblem (DAS)"));
        %}

PartialOutcomeQualifier [[P struct part_outcome *]]
%{
        ContinuationRef crefp;
%}
        ::=
        %{
        DLOG(log_dsap, LLOG_TRACE, ("About to encode PartialOutcomeQualifier (DAS)"));
        %}
        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>>
		    OPTIONAL
        }
        %{
        DLOG(log_dsap, LLOG_TRACE, ("Done encode PartialOutcomeQualifier (DAS)"));
        %}

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 (DAS)"));
        %}
        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 (DAS)"));
        %}

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) ,
        notAllowedOnNonLeaf(3) ,
        notAllowedOnRDN(4) ,
        entryAlreadyExists(5) ,
        affectsMultipleDSAs(6) ,
        objectClassModificationProhibited(7)
        }
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode UpdateProblem PE"));
        %}

DirectoryBindArgument [[P struct ds_bind_arg *]]
%{
/* Not used !!!
        USC             usc_s;
        USC             * usc = &(usc_s);
 */
%}
        ::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to encode DirectoryBindArgument"));
/* Not used !!!
 *              usc->usc_dn = parm->dba_dn;
 *		usc->usc_time1 = parm->dba_time1;
 *		usc->usc_time2 = parm->dba_time2;
 *              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 parm]]
                %{
                %}
                    OPTIONAL <<parm->dba_auth_type != DBA_AUTH_NONE>> ,
        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 [[p ca->ca_security]]
		    -- DEFAULT {} ,
		    OPTIONAL <<ca->ca_security>> ,
        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
	<<(parm->rda_common.ca_sig == (struct signature *) 0)? 1:2>>
	{
		ReadArgumentData [[p parm]] ,
		SEQUENCE
		{
			ReadArgumentData [[p parm]] ,
			AlgorithmIdentifier 
				[[p &(parm->rda_common.ca_sig->alg)]],
			BIT STRING
				[[x (parm->rda_common.ca_sig->encrypted) $
				    (parm->rda_common.ca_sig->n_bits) ]]
		}
	}
        %{
                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 [[p (struct security_parms *)0 ]]
		    -- OPTIONAL <<FALSE>> ,
		    OPTIONAL ,
        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 [[p (struct alg_id *)0 ]],
			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 [[p ca->ca_security]]
		    -- DEFAULT {} ,
		    OPTIONAL <<ca->ca_security>> ,
        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
	<<(parm->cma_common.ca_sig == (struct signature *) 0)? 1:2>>
	{
		CompareArgumentData [[p parm]] ,
		SEQUENCE
		{
			CompareArgumentData [[p parm]] ,
			AlgorithmIdentifier 
				[[p &(parm->cma_common.ca_sig->alg)]],
			BIT STRING
				[[x (parm->cma_common.ca_sig->encrypted) $
				    (parm->cma_common.ca_sig->n_bits) ]]
		}
	}
        %{
                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 == E_DATA_MASTER)]]
                %{
                %}
                    -- DEFAULT TRUE <<parm->cmr_iscopy != TRUE>> ,
                    OPTIONAL <<parm->cmr_iscopy != E_DATA_MASTER>> ,
		[30] SecurityParameters [[p (struct security_parms *)0 ]]
		    -- OPTIONAL <<FALSE>> ,
		    OPTIONAL ,
        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 [[p (struct alg_id *)0 ]],
			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 [[p ca->ca_security]]
		    -- DEFAULT {} ,
		    OPTIONAL <<ca->ca_security>> ,
        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
	<<(parm->lsa_common.ca_sig == (struct signature *) 0)? 1:2>>
	{
		ListArgumentData [[p parm]] ,
		SEQUENCE
		{
			ListArgumentData [[p parm]] ,
			AlgorithmIdentifier 
				[[p &(parm->lsa_common.ca_sig->alg) ]],
			BIT STRING
				[[x (parm->lsa_common.ca_sig->encrypted) $
				    (parm->lsa_common.ca_sig->n_bits) ]]
		}
	}
        %{
                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 == E_DATA_MASTER)]]
                                        %{
                                        %}
                                            -- DEFAULT TRUE <<sub_temp->sub_copy != E_DATA_MASTER>>
                                            OPTIONAL <<sub_temp->sub_copy != E_DATA_MASTER>>
                                }
                                %{
                                %}
                        %{
                        %} ,
                partialOutcomeQualifier
                        [2] PartialOutcomeQualifier [[p poq]]
                        %{
                        %}
                            OPTIONAL <<((poq->poq_limitproblem != LSR_NOLIMITPROBLEM) || (poq->poq_cref != NULLCONTINUATIONREF))>> ,
			[30] SecurityParameters [[p (struct security_parms *)0 ]]
			    -- OPTIONAL <<FALSE>> ,
			    OPTIONAL ,
                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 [[p (struct alg_id *)0 ]],
			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 [[b parm->sra_searchaliases]]
		    -- DEFAULT TRUE ,
		    OPTIONAL <<parm->sra_searchaliases != TRUE>> ,
        selection
                [4] EntryInformationSelection [[p &(parm->sra_eis)]]
                %{
                %}
                    -- DEFAULT {} ,
                    OPTIONAL <<TRUE>> ,
                [30] ServiceControls [[p &(ca->ca_servicecontrol)]]
                %{
                %}
                    -- DEFAULT {} ,
                    OPTIONAL <<TRUE>> ,
		[29] SecurityParameters [[p ca->ca_security]]
		    -- DEFAULT {} ,
		    OPTIONAL <<ca->ca_security>> ,
        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, ("About to encode SearchArgument (DAS)"));
        %}
	CHOICE
	<<(parm->sra_common.ca_sig == (struct signature *) 0)? 1:2>>
	{
		SearchArgumentData [[p parm]] ,
		SEQUENCE
		{
			SearchArgumentData [[p parm]] ,
			AlgorithmIdentifier 
				[[p &(parm->sra_common.ca_sig->alg) ]],
			BIT STRING
				[[x (parm->sra_common.ca_sig->encrypted) $
				    (parm->sra_common.ca_sig->n_bits) ]]
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done encode SearchArgument (DAS)"));
        %}

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 [[p (struct security_parms *)0 ]]
			    -- OPTIONAL <<FALSE>> ,
			    OPTIONAL ,
                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 [[p (struct alg_id *)0 ]],
			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 [[p ca->ca_security]]
		    -- DEFAULT {} ,
		    OPTIONAL <<ca->ca_security>> ,
        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
	<<(parm->ada_common.ca_sig == (struct signature *) 0)? 1:2>>
	{
		AddEntryArgumentData [[p parm]] ,
		SEQUENCE
		{
			AddEntryArgumentData [[p parm]] ,
			AlgorithmIdentifier 
				[[p &(parm->ada_common.ca_sig->alg) ]],
			BIT STRING
				[[x (parm->ada_common.ca_sig->encrypted) $
				    (parm->ada_common.ca_sig->n_bits) ]]
		}
	}
        %{
                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 [[p ca->ca_security]]
		    -- DEFAULT {} ,
		    OPTIONAL <<ca->ca_security>> ,
        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
	<<(parm->rma_common.ca_sig == (struct signature *) 0)? 1:2>>
	{
		RemoveEntryArgumentData [[p parm]] ,
		SEQUENCE
		{
			RemoveEntryArgumentData [[p parm]] ,
			AlgorithmIdentifier 
				[[p &(parm->rma_common.ca_sig->alg) ]],
			BIT STRING
				[[x (parm->rma_common.ca_sig->encrypted) $
				    (parm->rma_common.ca_sig->n_bits) ]]
		}
	}
        %{
                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 [[p ca->ca_security]]
		    -- DEFAULT {} ,
		    OPTIONAL <<ca->ca_security>> ,
        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
	<<(parm->mea_common.ca_sig == (struct signature *) 0) ? 1 : 2>>
	{
		ModifyEntryArgumentData [[p parm]] ,
		SEQUENCE
		{
			ModifyEntryArgumentData [[p parm]] ,
			AlgorithmIdentifier [[p &(parm->mea_common.ca_sig->alg)]],
			BIT STRING [[x (parm->mea_common.ca_sig->encrypted) $ (parm->mea_common.ca_sig->n_bits) ]]
		}
	}
        %{
                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 [[p ca->ca_security]]
		    -- DEFAULT {} ,
		    OPTIONAL <<ca->ca_security>> ,
        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
	<<(parm->mra_common.ca_sig == (struct signature *) 0)? 1:2>>
	{
		ModifyRDNArgumentData [[p parm]] ,
		SEQUENCE
		{
			ModifyRDNArgumentData [[p parm]] ,
			AlgorithmIdentifier
				[[p &(parm->mra_common.ca_sig->alg)]],
			BIT STRING [[x (parm->mra_common.ca_sig->encrypted) $
				(parm->mra_common.ca_sig->n_bits) ]]
		}
	}
        %{
                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"));
        %}

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
DataMuseum.dk

DKUUG/EUUG Conference tapes

⟦3acb28c09⟧ TextFile

Derivation

TextFile
