DataMuseum.dk

Presents historical artifacts from the history of:

DKUUG/EUUG Conference tapes

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about DKUUG/EUUG Conference tapes

Excavated with: AutoArchaeologist - Free & Open Source Software. 

top - metrics - download
Index: T d

⟦c1ce70e7a⟧ TextFile

    Length: 25280 (0x62c0)
    Types: TextFile
    Names: »do-dec.py«

Derivation

└─⟦3d0c2be1b⟧ Bits:30001254 ISODE-5.0 Tape
    └─⟦eba4602b1⟧ »./isode-5.0.tar.Z« 
        └─⟦d3ac74d73⟧ 
            └─⟦this⟧ »isode-5.0/dsap/x500as/do-dec.py«

TextFile

-- do-dec.py - manually augmented DistributedOperations module

-- $Header: /f/osi/dsap/x500as/RCS/do-dec.py,v 6.0 89/03/18 23:29:27 mrose Rel $
--
--
-- $Log:	do-dec.py,v $
-- Revision 6.0  89/03/18  23:29:27  mrose
-- Release 5.0
-- 

--
--				  NOTICE
--
--    Acquisition, use, and distribution of this module and related
--    materials are subject to the restrictions of a license agreement.
--    Consult the Preface in the User's Manual for the full terms of
--    this agreement.
--
--


DO
	{
	joint-iso-ccitt
	ds(5)
	modules(1)
	distributedOperations(3)
	}

DEFINITIONS ::=

%{
#include "quipu/util.h"
#include "quipu/entry.h"
#include "quipu/common.h"
#include "quipu/dsargument.h"

extern  LLog    * log_dsap;

void bcopy ();

#define getstr(ss,sl,ds,dl,dn,w) \
        if (sl > dn) { \
            advise (NULLCP, "%s too long", w); \
            return NOTOK; \
        } \
        bcopy (ss, ds, dl = sl);

#define	decode_DSE_PSAPaddr	parse_DSE_PSAPaddr

%}

PREFIXES encode decode print
BEGIN

-- EXPORTS
--	ContinuationReference ,
--	OperationProgress ,
-- 	DSAReferralParm;

IMPORTS
	DistinguishedName ,
	Name ,
	RelativeDistinguishedName
		FROM IF
			{
			joint-iso-ccitt
			ds(5)
			modules(1)
			informationFramework(1)
			}

	AlgorithmIdentifier
		FROM AF
			{
			joint-iso-ccitt
			ds(5)
			modules(1)
			authenticationFramework(7)
			}

	ReadArgument ,
	ReadResult ,
	CompareArgument ,
	CompareResult ,
	AbandonArgument ,
	AbandonResult ,
	ListArgument ,
	ListResult ,
	SearchArgument ,
	SearchResult ,
	AddEntryArgument ,
	AddEntryResult ,
	RemoveEntryArgument ,
	RemoveEntryResult ,
	ModifyEntryArgument ,
	ModifyEntryResult ,
	ModifyRDNArgument ,
	ModifyRDNResult ,
	SecurityParameters
		FROM DAS
			{
			joint-iso-ccitt
			ds(5)
			modules(1)
			directoryAbstractService(2)
			};

DECODER decode

ChainedReadArgument [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedReadArgument"));
        %}
	CHOICE
	{
		ChainedReadArgumentData [[p parm]] ,
		SEQUENCE
		{
			ChainedReadArgumentData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedReadArgument"));
        %}

ChainedReadArgumentData [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedReadArgumentData"));
		parm->dca_dsarg.arg_type = OP_READ;
        %}
	SET
	{
		ChainingArgument [[p &(parm->dca_charg)]] ,
		[0] ReadArgument [[p &(parm->dca_dsarg.arg_rd)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedReadArgumentData"));
        %}

ChainedReadResult [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedReadResult"));
        %}
	CHOICE
	{
		ChainedReadResultData [[p parm]] ,
		SEQUENCE
		{
			ChainedReadResultData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedReadResult"));
        %}

ChainedReadResultData [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedReadResultData"));
		parm->dcr_dsres.result_type = OP_READ;
        %}
	SET
	{
		ChainingResult [[p &(parm->dcr_chres)]] ,
		[0] ReadResult [[p &(parm->dcr_dsres.res_rd)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedReadResultData"));
        %}

ChainedCompareArgument [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedCompareArgument"));
        %}
	CHOICE
	{
		ChainedCompareArgumentData [[p parm]] ,
		SEQUENCE
		{
			ChainedCompareArgumentData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedCompareArgument"));
        %}

ChainedCompareArgumentData [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedCompareArgumentData"));
		parm->dca_dsarg.arg_type = OP_COMPARE;
        %}
	SET
	{
		ChainingArgument [[p &(parm->dca_charg)]] ,
		[0] CompareArgument [[p &(parm->dca_dsarg.arg_cm)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedCompareArgumentData"));
        %}

ChainedCompareResult [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedCompareResult"));
        %}
	CHOICE
	{
		ChainedCompareResultData [[p parm]] ,
		SEQUENCE
		{
			ChainedCompareResultData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedCompareResult"));
        %}

ChainedCompareResultData [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedCompareResultData"));
		parm->dcr_dsres.result_type = OP_COMPARE;
        %}
	SET
	{
		ChainingResult [[p &(parm->dcr_chres)]] ,
		[0] CompareResult [[p &(parm->dcr_dsres.res_cm)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedCompareResultData"));
        %}

ChainedAbandonArgument [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedAbandonArgument"));
		parm->dca_dsarg.arg_type = OP_ABANDON;
        %}
	AbandonArgument [[p &(parm->dca_dsarg.arg_ab)]]
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedAbandonArgument"));
        %}

ChainedAbandonResult [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedAbandonResult"));
		parm->dcr_dsres.result_type = OP_ABANDON;
        %}
	AbandonResult
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedAbandonResult"));
        %}

ChainedListArgument [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedListArgument"));
        %}
	CHOICE
	{
		ChainedListArgumentData [[p parm]] ,
		SEQUENCE
		{
			ChainedListArgumentData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedListArgument"));
        %}

ChainedListArgumentData [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedListArgumentData"));
		parm->dca_dsarg.arg_type = OP_LIST;
        %}
	SET
	{
		ChainingArgument [[p &(parm->dca_charg)]] ,
		[0] ListArgument [[p &(parm->dca_dsarg.arg_ls)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedListArgumentData"));
        %}

ChainedListResult [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedListResult"));
        %}
	CHOICE
	{
		ChainedListResultData [[p parm]] ,
		SEQUENCE
		{
			ChainedListResultData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedListResult"));
        %}

ChainedListResultData [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedListResultData"));
		parm->dcr_dsres.result_type = OP_LIST;
        %}
	SET
	{
		ChainingResult [[p &(parm->dcr_chres)]] ,
		[0] ListResult [[p &(parm->dcr_dsres.res_ls)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedListResultData"));
        %}

ChainedSearchArgument [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedSearchArgument"));
        %}
	CHOICE
	{
		ChainedSearchArgumentData [[p parm]] ,
		SEQUENCE
		{
			ChainedSearchArgumentData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedSearchArgument"));
        %}

ChainedSearchArgumentData [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedSearchArgumentData"));
		parm->dca_dsarg.arg_type = OP_SEARCH;
        %}
	SET
	{
		ChainingArgument [[p &(parm->dca_charg)]] ,
		[0] SearchArgument [[p &(parm->dca_dsarg.arg_sr)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedSearchArgumentData"));
        %}

ChainedSearchResult [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedSearchResult"));
        %}
	CHOICE
	{
		ChainedSearchResultData [[p parm]] ,
		SEQUENCE
		{
			ChainedSearchResultData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedSearchResult"));
        %}

ChainedSearchResultData [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedSearchResultData"));
		parm->dcr_dsres.result_type = OP_SEARCH;
        %}
	SET
	{
		ChainingResult [[p &(parm->dcr_chres)]] ,
		[0] SearchResult [[p &(parm->dcr_dsres.res_sr)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedSearchResultData"));
        %}

ChainedAddEntryArgument [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedAddEntryArgument"));
        %}
	CHOICE
	{
		ChainedAddEntryArgumentData [[p parm]] ,
		SEQUENCE
		{
			ChainedAddEntryArgumentData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedAddEntryArgument"));
        %}

ChainedAddEntryArgumentData [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedAddEntryArgumentData"));
		parm->dca_dsarg.arg_type = OP_ADDENTRY;
        %}
	SET
	{
		ChainingArgument [[p &(parm->dca_charg)]] ,
		[0] AddEntryArgument [[p &(parm->dca_dsarg.arg_ad)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedAddEntryArgumentData"));
        %}

ChainedAddEntryResult [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedAddEntryResult"));
        %}
	CHOICE
	{
		ChainedAddEntryResultData [[p parm]] ,
		SEQUENCE
		{
			ChainedAddEntryResultData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedAddEntryResult"));
        %}

ChainedAddEntryResultData [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedAddEntryArgumentResultData"));
		parm->dcr_dsres.result_type = OP_ADDENTRY;
        %}
	SET
	{
		ChainingResult [[p &(parm->dcr_chres)]] ,
		[0] AddEntryResult
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedAddEntryArgumentResultData"));
        %}

ChainedRemoveEntryArgument [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedRemoveEntryArgument"));
        %}
	CHOICE
	{
		ChainedRemoveEntryArgumentData [[p parm]] ,
		SEQUENCE
		{
			ChainedRemoveEntryArgumentData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedRemoveEntryArgument"));
        %}

ChainedRemoveEntryArgumentData [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedRemoveEntryArgumentData"));
		parm->dca_dsarg.arg_type = OP_REMOVEENTRY;
        %}
	SET
	{
		ChainingArgument [[p &(parm->dca_charg)]] ,
		[0] RemoveEntryArgument [[p &(parm->dca_dsarg.arg_rm)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedRemoveEntryArgumentData"));
        %}

ChainedRemoveEntryResult [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedRemoveEntryResult"));
        %}
	CHOICE
	{
		ChainedRemoveEntryResultData [[p parm]] ,
		SEQUENCE
		{
			ChainedRemoveEntryResultData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedRemoveEntryResult"));
        %}

ChainedRemoveEntryResultData [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedRemoveEntryResultData"));
		parm->dcr_dsres.result_type = OP_REMOVEENTRY;
        %}
	SET
	{
		ChainingResult [[p &(parm->dcr_chres)]] ,
		[0] RemoveEntryResult
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedRemoveEntryResultData"));
        %}

ChainedModifyEntryArgument [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedModifyEntryArgument"));
        %}
	CHOICE
	{
		ChainedModifyEntryArgumentData [[p parm]] ,
		SEQUENCE
		{
			ChainedModifyEntryArgumentData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedModifyEntryArgument"));
        %}

ChainedModifyEntryArgumentData [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedModifyEntryArgumentData"));
		parm->dca_dsarg.arg_type = OP_MODIFYENTRY;
        %}
	SET
	{
		ChainingArgument [[p &(parm->dca_charg)]] ,
		[0] ModifyEntryArgument [[p &(parm->dca_dsarg.arg_me)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedModifyEntryArgumentData"));
        %}

ChainedModifyEntryResult [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedModifyEntryResult"));
        %}
	CHOICE
	{
		ChainedModifyEntryResultData [[p parm]] ,
		SEQUENCE
		{
			ChainedModifyEntryResultData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedModifyEntryResult"));
        %}

ChainedModifyEntryResultData [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedModifyEntryResultData"));
		parm->dcr_dsres.result_type = OP_MODIFYENTRY;
        %}
	SET
	{
		ChainingResult [[p &(parm->dcr_chres)]] ,
		[0] ModifyEntryResult
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedModifyEntryResultData"));
        %}

ChainedModifyRDNArgument [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedModifyRDNArgument"));
        %}
	CHOICE
	{
		ChainedModifyRDNArgumentData [[p parm]] ,
		SEQUENCE
		{
			ChainedModifyRDNArgumentData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedModifyRDNArgument"));
        %}

ChainedModifyRDNArgumentData [[P struct ds_op_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedModifyRDNArgumentData"));
		parm->dca_dsarg.arg_type = OP_MODIFYRDN;
        %}
	SET
	{
		ChainingArgument [[p &(parm->dca_charg)]] ,
		[0] ModifyRDNArgument [[p &(parm->dca_dsarg.arg_mr)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedModifyRDNArgumentData"));
        %}

ChainedModifyRDNResult [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedModifyRDNResult"));
        %}
	CHOICE
	{
		ChainedModifyRDNResultData [[p parm]] ,
		SEQUENCE
		{
			ChainedModifyRDNResultData [[p parm]] ,
			AlgorithmIdentifier ,
			BIT STRING
		}
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedModifyRDNResult"));
        %}

ChainedModifyRDNResultData [[P struct ds_op_res *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainedModifyRDNResultData"));
		parm->dcr_dsres.result_type = OP_MODIFYRDN;
        %}
	SET
	{
		ChainingResult [[p &(parm->dcr_chres)]] ,
		[0] ModifyRDNResult
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainedModifyRDNResultData"));
        %}

DSAReferralParm [[P struct DSE_referral *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode DSAReferralParm"));
		parm->DSE_ref_prefix = NULLDN;
		parm->DSE_ref_candidates = (ContinuationRef) smalloc(sizeof(continuation_ref));
        %}
	SET
	{
		[0] ContinuationReference [[p parm->DSE_ref_candidates]] ,
	contextPrefix
		[1] DistinguishedName [[p &(parm->DSE_ref_prefix)]]
		    OPTIONAL
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode DSAReferralParm"));
        %}

ChainingArgument [[P struct chain_arg *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainingArgument"));
		parm->cha_originator = NULLDN;
		parm->cha_target = NULLDN;
		parm->cha_progress.op_resolution_phase = OP_PHASE_NOTSTARTED;
		parm->cha_progress.op_nextrdntoberesolved = 0;
		parm->cha_aliasderef = FALSE;
		parm->cha_aliasedrdns = 0;
		parm->cha_returnrefs = FALSE;
		parm->cha_reftype = RT_SUPERIOR;
		parm->cha_domaininfo = NULLPE;
        %}
	SET
	{
	originator
		[0] DistinguishedName [[p &(parm->cha_originator)]]
		    OPTIONAL ,
	targetObject
		[1] DistinguishedName [[p &(parm->cha_target)]]
		    OPTIONAL ,
	operationProgress
		[2] OperationProgress [[p &(parm->cha_progress)]]
		    -- DEFAULT {notStarted} ,
		    OPTIONAL ,
	traceInformation
		[3] TraceInformation [[p &(parm->cha_trace)]] ,
	aliasDereferenced
		[4] BOOLEAN [[b parm->cha_aliasderef]]
		    -- DEFAULT FALSE ,
		    OPTIONAL ,
	aliasedRDNs
		[5] INTEGER [[i parm->cha_aliasedrdns]]
		    OPTIONAL ,
		-- absent unless aliasDereferenced is TRUE
	returnCrossRefs
		[6] BOOLEAN [[b parm->cha_returnrefs]]
		    -- DEFAULT FALSE ,
		    OPTIONAL ,
	referenceType
		[7] ReferenceType [[p &(parm->cha_reftype)]]
		    -- DEFAULT superior ,
		    OPTIONAL ,
	info
		[8] DomainInfo [[p &(parm->cha_domaininfo)]]
		    OPTIONAL ,
	timeLimit
		[9] UTCTime
		    OPTIONAL ,
		[10] SecurityParameters
		    -- DEFAULT {}
		    OPTIONAL
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainingArgument"));
        %}

ChainingResult [[P struct chain_res *]]
%{
	struct cross_ref	**xrefp;
%}
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ChainingResult"));
		parm->chr_domaininfo = NULLPE;
		parm->chr_crossrefs = NULLXREF;
        %}
	SET
	{
	info
		[0] DomainInfo [[p &(parm->chr_domaininfo)]]
		    OPTIONAL ,
	crossReferences
		%{
			xrefp = &(parm->chr_crossrefs);
		%}
		[1] SEQUENCE OF
			%{
				(*xrefp) = (struct cross_ref *) smalloc(sizeof(struct cross_ref));
			%}
			CrossReference [[p (*xrefp)]]
			%{
				xrefp = &((*xrefp)->xref_next);
			%}
		%{
			(*xrefp) = NULLXREF;
		%}
		    OPTIONAL ,
		[2] SecurityParameters
		    -- DEFAULT {}
		    OPTIONAL
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ChainingResult"));
        %}

CrossReference [[P struct cross_ref *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode CrossReference"));
		parm->xref_dn = NULLDN;
		parm->xref_ap = NULLACCESSPOINT;
        %}
	SET
	{
	contextPrefix
		[0] DistinguishedName [[p &(parm->xref_dn)]] ,
	accessPoint
		[1] AccessPoint [[p parm->xref_ap]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode CrossReference"));
        %}

ReferenceType [[P int*]]
%{
%}
        ::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ReferenceType"));
        %}
        ENUMERATED [[i (*parm)]]
        {
        superior(1) ,
        subordinate(2) ,
        cross(3) ,
        nonSpecificSubordinate(4)
        }
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ReferenceType"));
        %}

TraceInformation [[P struct trace_info **]]
%{
	struct trace_info	**tip;
%}
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode TraceInformation"));
		(*parm) = NULLTRACEINFO;
		tip = parm;
        %}
	SEQUENCE OF
		%{
			(*tip) = (struct trace_info *) malloc(sizeof(struct trace_info));
		%}
		TraceItem [[p (*tip)]]
		%{
			tip = &((*tip)->ti_next);
		%}
        %{
		(*tip) = NULLTRACEINFO;
                DLOG(log_dsap, LLOG_TRACE, ("Done decode TraceInformation"));
        %}

TraceItem [[P struct trace_info *]]
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode TraceItem"));
		parm->ti_dsa = NULLDN;
		parm->ti_target = NULLDN;
        %}
	SET
	{
	dsa
		[0] Name [[p &(parm->ti_dsa)]] ,
	targetObject
		[1] Name [[p &(parm->ti_target)]]
		    OPTIONAL ,
	operationProgress
		[2] OperationProgress [[p &(parm->ti_progress)]]
	}
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode TraceItem"));
        %}

OperationProgress [[P struct op_progress *]]
%{
        int     phase;
%}
        ::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode OperationProgress"));
                parm->op_resolution_phase = 0;
                parm->op_nextrdntoberesolved = 0;
        %}
        SET
        {
        nameResolutionPhase
                [0] ENUMERATED [[i phase]]
                {
                notStarted(1) ,
                proceeding(2) ,
                completed(3)
                }
                %{
                        parm->op_resolution_phase = phase - 1;
                %} ,
        nextRDNToBeResolved
                [1] INTEGER [[i parm->op_nextrdntoberesolved]]
                %{
                %}
		    OPTIONAL
        }
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode OperationProgress"));
        %}

DomainInfo [[P PE *]]
%{
	PE	  old_pe;
%}
	::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode DomainInfo"));
        %}
	ANY [[a old_pe]]
        %{
		(*parm) = pe_cpy(old_pe);
                DLOG(log_dsap, LLOG_TRACE, ("Done decode DomainInfo"));
        %}

ContinuationReference [[P struct continuation_ref *]]
%{
        struct  access_point    *app;
        int             not_first_ap;
%}
        ::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode ContinuationReference"));
                parm->cr_name = NULLDN;
                parm->cr_rdn_resolved = CR_RDNRESOLVED_NOTDEFINED;
                parm->cr_reftype = RT_UNDEFINED;
                parm->cr_next = NULLCONTINUATIONREF;
                app = &(parm->cr_accesspoints);
                app->ap_name = NULLDN;
                app->ap_address.pa_selectlen = 0;
                app->ap_address.pa_addr.sa_selectlen = 0;
                app->ap_address.pa_addr.sa_addr.ta_selectlen = 0;
                app->ap_address.pa_addr.sa_addr.ta_naddr = 0;
                app->ap_next = NULLACCESSPOINT;
                not_first_ap = FALSE;
        %}
        SET
        {
        targetObject
                [0] Name [[p &(parm->cr_name)]]
                %{
                %} ,
        aliasedRDNs
                [1] INTEGER [[i parm->cr_aliasedRDNs]]
                %{
                %}
                    OPTIONAL ,
        operationProgress
                [2] OperationProgress [[p &(parm->cr_progress)]]
                %{
                %} ,
        rdnsResolved
                [3] INTEGER [[i parm->cr_rdn_resolved]]
                %{
                %}
                    OPTIONAL ,
        referenceType
                [4] ReferenceType [[p &(parm->cr_reftype)]]
                %{
                %}
                    OPTIONAL ,
        accessPoints
                [5] SET OF
                %{
                        if(not_first_ap)
                        {
                                app->ap_next = (struct access_point *) smalloc(sizeof(struct access_point));
                                app = app->ap_next;
                        }
                        not_first_ap = TRUE;
                %}
                        AccessPoint [[p app]]
                        %{
                        %}
                %{
                %}
        }
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode ContinuationReference"));
        %}

AccessPoint [[P struct access_point *]]
%{
%}
        ::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode AccessPoint"));
                parm->ap_name = NULLDN;
                parm->ap_next = NULLACCESSPOINT;
        %}
        SET
        {
                [0] Name [[p &(parm->ap_name)]]
                %{
                %} ,
                [1] ISODEPresentationAddress [[p &(parm->ap_address)]]
                %{
                %}
        }
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode AccessPoint"));
        %}

ISODEPresentationAddress [[P struct PSAPaddr * ]]
    ::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode PresentationAddress"));
        %}
	DSE.PSAPaddr [[p parm]]
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode PresentationAddress"));
        %}

InvokeID [[P int*]]
%{
%}
        ::=
        %{
                DLOG(log_dsap, LLOG_TRACE, ("About to decode InvokeID"));
        %}
        INTEGER [[i (*parm)]]
        %{
                DLOG(log_dsap, LLOG_TRACE, ("Done decode InvokeID"));
        %}

END