das.py

来自「ftam等标准协议服务器和客户端的源代码。」· Python 代码 · 共 1,594 行 · 第 1/3 页

	cannotAbandon(3)
	}

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

-- Pulled up
NameProblem
	::=
	INTEGER
	{
	noSuchObject(1) ,
	aliasProblem(2) ,
	invalidAttributeSyntax(3) ,
	aliasDereferencingProblem(4)
	}

-- Pulled up
UpdateProblem
	::=
	INTEGER
	{
	namingViolation(1) ,
	objectClassViolation(2) ,
	notAllowedOnNonLeaf(3) ,
	notAllowedOnRDN(4) ,
	entryAlreadyExists(5) ,
	affectsMultipleDSAs(6) ,
	objectClassModificationProhibited(7)
	}

DirectoryBindArgument [[P struct ds_bind_arg *]]
	::=
	SET
	{
	%D{
	   (*parm)->dba_version = DBA_VERSION_V1988;
	%}
	credentials
		[0] Credentials [[p *]]
		    OPTIONAL 
		    <E<  ((parm->dba_auth_type != DBA_AUTH_NONE) || 
			     (parm->dba_dn != NULLDN))  >>
		    <D<0>>,
	    %E{
		    if (parm->dba_version == DBA_VERSION_V1988) {
		       parm->dba_vlen = 1;
		       parm->dba_vtmp = int2strb_alloc(parm->dba_version,1);
		    } else
		      return NOTOK;
	    %}
	versions
		[1] Versions [[x dba_vtmp $ dba_vlen ]]
		    %E{
		    if (parm->dba_vtmp)
			free (parm->dba_vtmp);
		    %}
		    %D{
		        if ( (*parm)->dba_vlen ) {
			   (*parm)->dba_version = strb2int((*parm)->dba_vtmp,(*parm)->dba_vlen);
			   free ((*parm)->dba_vtmp);
			}
		    %}
		    -- DEFAULT {v1988}
		    OPTIONAL <E<parm->dba_version != DBA_VERSION_V1988>><D<0>>
	}

DirectoryBindResult [[P struct ds_bind_arg *]]
	::=
	DirectoryBindArgument [[p *]]

ReadArgumentData [[P struct ds_read_arg *]]
	::=
	SET
	{
	%D{
	(*parm)->rda_eis.eis_allattributes = TRUE;
	(*parm)->rda_eis.eis_infotypes = EIS_ATTRIBUTESANDVALUES;
	(*parm)->rda_common.ca_servicecontrol.svc_prio = SVC_PRIO_MED;
	(*parm)->rda_common.ca_servicecontrol.svc_timelimit = SVC_NOTIMELIMIT;
	(*parm)->rda_common.ca_servicecontrol.svc_sizelimit = SVC_NOSIZELIMIT;
	(*parm)->rda_common.ca_servicecontrol.svc_scopeofreferral = SVC_REFSCOPE_NONE;
	(*parm)->rda_common.ca_aliased_rdns = CA_NO_ALIASDEREFERENCED;
	%}
	object
		[0] Name [[p rda_object]],
	selection
		[1] EntryInformationSelection [[p &parm->rda_eis]]
		    -- DEFAULT {},
		    OPTIONAL <D<0>>
			     <E< (
			     (parm->rda_eis.eis_allattributes != TRUE) ||
			     (parm->rda_eis.eis_infotypes != EIS_ATTRIBUTESANDVALUES)
			     ) >>,
		[30] ServiceControls [[p &parm->rda_common.ca_servicecontrol]]
		    -- DEFAULT {},
		    OPTIONAL <D<0>>
		    <E< (
		    (parm->rda_common.ca_servicecontrol.svc_options != 0) ||
		    (parm->rda_common.ca_servicecontrol.svc_prio != SVC_PRIO_MED) ||
		    (parm->rda_common.ca_servicecontrol.svc_timelimit != SVC_NOTIMELIMIT) ||
		    (parm->rda_common.ca_servicecontrol.svc_sizelimit != SVC_NOSIZELIMIT) ||
		    (parm->rda_common.ca_servicecontrol.svc_scopeofreferral != SVC_REFSCOPE_NONE)
		    ) >>,
		[29] SecurityParameters [[p rda_common.ca_security]]
		    -- DEFAULT {},
		    OPTIONAL,
	requestor
		[28] DistinguishedName [[p rda_common.ca_requestor]]
		    OPTIONAL,
		[27] OperationProgress [[p &parm->rda_common.ca_progress]]
		    OPTIONAL <D<0>>
		    <E<parm->rda_common.ca_progress.op_resolution_phase > 1>>,
	aliasedRDNs
		[26] INTEGER [[i parm->rda_common.ca_aliased_rdns]]
		    OPTIONAL <E<parm->rda_common.ca_aliased_rdns != CA_NO_ALIASDEREFERENCED>>
		    <D<0>>,
	extensions
		[25] SET OF [[ T struct extension * $ rda_common.ca_extensions ]] <<ext_next>>
			Extension [[p *]]
		    OPTIONAL
	}

ReadArgument [[P struct ds_read_arg *]]
	::=
	CHOICE <D<0>>
	       <E< parm->rda_common.ca_sig == (struct signature *) 0 ? 1 : 2>>
	{
		ReadArgumentData [[p * ]] ,
		SEQUENCE [[ T struct ds_read_arg * $ * ]]
		{
			ReadArgumentData [[p * ]] ,
			TAlgorithmIdentifier [[p parm->rda_common.ca_sig]],
			TBitString [[p parm->rda_common.ca_sig]]
		}
	}

ReadResultData [[P struct ds_read_result *]]
	::=
	SET
	{
	entry
		[0] EntryInformation [[p  &parm->rdr_entry]],
		[30] SecurityParameters [[p parm->rdr_common.cr_security ]]
		    OPTIONAL ,
	performer
		[29] DistinguishedName [[p parm->rdr_common.cr_requestor]]
		    OPTIONAL,
	aliasDereferenced
		[28] BOOLEAN [[b rdr_common.cr_aliasdereferenced]]
		    DEFAULT FALSE 
	}

ReadResult [[P struct ds_read_result *]]
	::=
	CHOICE <E<1>><D<0>>
	{
		ReadResultData [[p * ]] ,
		SEQUENCE [[ T struct ds_read_result * $ * ]]
		{
			ReadResultData [[p * ]] ,
			AlgorithmIdentifier [[p rdr_common.cr_alg]],
			BIT STRING [[ x rdr_common.cr_tmp $ rdr_common.cr_len ]]
		}
	}

CompareArgumentData [[P struct ds_compare_arg *]]
	::=
	SET
	{
	%D{
	(*parm)->cma_common.ca_servicecontrol.svc_prio = SVC_PRIO_MED;
	(*parm)->cma_common.ca_servicecontrol.svc_timelimit = SVC_NOTIMELIMIT;
	(*parm)->cma_common.ca_servicecontrol.svc_sizelimit = SVC_NOSIZELIMIT;
	(*parm)->cma_common.ca_servicecontrol.svc_scopeofreferral = SVC_REFSCOPE_NONE;
	(*parm)->cma_common.ca_aliased_rdns = CA_NO_ALIASDEREFERENCED;
	%}
	object
		[0] Name [[p cma_object]],
	purported
		[1] AttributeValueAssertion [[p &parm->cma_purported]],
		[30] ServiceControls [[p &parm->cma_common.ca_servicecontrol]]
		     -- DEFAULT {} ,
		    OPTIONAL <D<0>>
		    <E< (
		    (parm->cma_common.ca_servicecontrol.svc_options != 0) ||
		    (parm->cma_common.ca_servicecontrol.svc_prio != SVC_PRIO_MED) ||
		    (parm->cma_common.ca_servicecontrol.svc_timelimit != SVC_NOTIMELIMIT) ||
		    (parm->cma_common.ca_servicecontrol.svc_scopeofreferral != SVC_REFSCOPE_NONE)
		    ) >>,

		[29] SecurityParameters [[p parm->cma_common.ca_security]]
		     -- DEFAULT {},
		     OPTIONAL,
	requestor
		[28] DistinguishedName [[p parm->cma_common.ca_requestor]]
		     OPTIONAL,
		[27] OperationProgress [[p &parm->cma_common.ca_progress]]
		     OPTIONAL <D<0>>
		     <E<parm->cma_common.ca_progress.op_resolution_phase > 1>>,
	aliasedRDNs
		[26] INTEGER [[i parm->cma_common.ca_aliased_rdns]]
		     OPTIONAL <E<parm->cma_common.ca_aliased_rdns != CA_NO_ALIASDEREFERENCED>><D<0>> ,
	extensions
		[25] SET OF [[T struct extension * $ parm->cma_common.ca_extensions]]
		     <<ext_next>>  Extension [[p *]]
		     OPTIONAL
	}

CompareArgument [[P struct ds_compare_arg *]]
	::=
	CHOICE  <D<0>>
	<E<(parm->cma_common.ca_sig == (struct signature *) 0)? 1:2>>
	{
		CompareArgumentData [[p *]] ,
		SEQUENCE [[ T struct ds_compare_arg * $ *]]
		{
			CompareArgumentData [[p *]] ,
			TAlgorithmIdentifier 
				[[p parm->cma_common.ca_sig]],
			TBitString
				[[x parm->cma_common.ca_sig $ parm->cma_common.ca_sig ]]
		}
	}

CompareResultData [[P struct ds_compare_result *]]
	::=
	SET
	{
		DistinguishedName [[p cmr_object]]
		OPTIONAL,
	matched
		[0] BOOLEAN [[b parm->cmr_matched]],
		%E{
			if (parm->cmr_iscopy == INFO_MASTER)
			   parm->cmr_pepsycopy = TRUE;
			else
			   parm->cmr_pepsycopy = FALSE;
		%}
	fromEntry
		[1] BOOLEAN [[b parm->cmr_pepsycopy]]
		%D{
			if ((*parm)->cmr_pepsycopy)
			   (*parm)->cmr_iscopy = INFO_MASTER;
			else
			   (*parm)->cmr_iscopy = INFO_COPY;
		%}
		    DEFAULT TRUE,
		[30] SecurityParameters [[p parm->cmr_common.cr_security ]]
		    OPTIONAL ,
	performer
		[29] DistinguishedName [[p parm->cmr_common.cr_requestor]]
		OPTIONAL,
	aliasDereferenced
		[28] BOOLEAN [[b parm->cmr_common.cr_aliasdereferenced]]
		     DEFAULT FALSE
	}

CompareResult [[P struct ds_compare_result *]]
	::=
	CHOICE <D<0>><E<1>>
	{
		CompareResultData [[p *]] ,
		SEQUENCE [[ T struct ds_compare_result * $ *]]
		{
			CompareResultData [[p *]] ,
			AlgorithmIdentifier [[p cmr_common.cr_alg]],
			BIT STRING [[ x cmr_common.cr_tmp $ cmr_common.cr_len ]]
		}
	}

-- For pepsy as it can't pull up struct not defined here.
TInvokeID ::= INTEGER

AbandonArgument [[P struct ds_abandon_arg *]]
	::=
	SEQUENCE
	{
	invokeID
		[0] TInvokeID [[i parm->aba_invokeid]]
	}

AbandonResult ::= NULL

ListArgumentData [[P struct ds_list_arg *]]
	::=
	SET
	{
	%D{
	(*parm)->lsa_common.ca_servicecontrol.svc_prio = SVC_PRIO_MED;
	(*parm)->lsa_common.ca_servicecontrol.svc_timelimit = SVC_NOTIMELIMIT;
	(*parm)->lsa_common.ca_servicecontrol.svc_sizelimit = SVC_NOSIZELIMIT;
	(*parm)->lsa_common.ca_servicecontrol.svc_scopeofreferral = SVC_REFSCOPE_NONE;
	(*parm)->lsa_common.ca_aliased_rdns = CA_NO_ALIASDEREFERENCED;
	%}
	object
		[0] Name [[p parm->lsa_object]],
		[30] ServiceControls [[p &parm->lsa_common.ca_servicecontrol]]
		     -- DEFAULT {},
		    OPTIONAL <D<0>>
		    <E< (
		    (parm->lsa_common.ca_servicecontrol.svc_options != 0) ||
		    (parm->lsa_common.ca_servicecontrol.svc_prio != SVC_PRIO_MED) ||
		    (parm->lsa_common.ca_servicecontrol.svc_timelimit != SVC_NOTIMELIMIT) ||
		    (parm->lsa_common.ca_servicecontrol.svc_sizelimit != SVC_NOSIZELIMIT) ||
		    (parm->lsa_common.ca_servicecontrol.svc_scopeofreferral != SVC_REFSCOPE_NONE)
		    ) >>,

		[29] SecurityParameters [[p parm->lsa_common.ca_security]]
		     -- DEFAULT {} ,
		     OPTIONAL,
	requestor
		[28] DistinguishedName [[p  parm->lsa_common.ca_requestor]]
		     OPTIONAL,
		[27] OperationProgress [[p &parm->lsa_common.ca_progress]]
		     OPTIONAL <D<0>>
		     <E<parm->lsa_common.ca_progress.op_resolution_phase > 1>>,
	aliasedRDNs
		[26] INTEGER [[i parm->lsa_common.ca_aliased_rdns]]
		     OPTIONAL <E<parm->lsa_common.ca_aliased_rdns != CA_NO_ALIASDEREFERENCED>> <D<0>>
		,
	extensions
		[25] SET OF [[ T struct extension * $ parm->lsa_common.ca_extensions ]]
		     <<ext_next>> Extension [[p *]]
		     OPTIONAL
	}

ListArgument [[P struct ds_list_arg *]]
	::=
	CHOICE <D<0>>
	<E<(parm->lsa_common.ca_sig == (struct signature *) 0)? 1:2>>
	{
		ListArgumentData [[p *]] ,
		SEQUENCE [[ T struct ds_list_arg * $ * ]]
		{
			ListArgumentData [[p *]] ,
			TAlgorithmIdentifier [[p parm->lsa_common.ca_sig ]],
			TBitString [[ p parm->lsa_common.ca_sig ]]
		}
	}

ListResultData [[P struct ds_list_result *]]
	::=
	CHOICE <E<1>><D<0>>
	{
	listInfo
		SET [[ T struct ds_list_result * $ * ]]
		{
		DistinguishedName [[p parm->lsr_object]] OPTIONAL,
		subordinates
			[1] SET OF [[T struct subordinate * $ lsr_subordinates ]]
			<<sub_next>>
				SEQUENCE [[ T struct subordinate * $ *]]
				{
					RelativeDistinguishedName [[p sub_rdn]],
				aliasEntry
					[0] BOOLEAN [[b sub_aliasentry]] 
					    DEFAULT FALSE,
				fromEntry
					[1] BOOLEAN [[b sub_copy]]
					    DEFAULT TRUE
				},
	%D{
		(*parm)->lsr_poq.poq_limitproblem = LSR_NOLIMITPROBLEM;
	%}
		partialOutcomeQualifier
			[2] PartialOutcomeQualifier [[p &parm->lsr_poq]]
			     OPTIONAL <E<
				      ((parm->lsr_poq.poq_limitproblem != LSR_NOLIMITPROBLEM) || 
				      (parm->lsr_poq.poq_cref != NULLCONTINUATIONREF))
				      >><D<0>>,
			[30] SecurityParameters [[p parm->lsr_common.cr_security ]]
			    OPTIONAL ,
		performer
			[29] DistinguishedName [[p parm->lsr_common.cr_requestor]]
			OPTIONAL,
		aliasDereferenced
			[28] BOOLEAN [[b parm->lsr_common.cr_aliasdereferenced]]
			     DEFAULT FALSE
		},

	uncorrelatedListInfo
		[0] SET OF [[ T struct ds_list_result * $ lsr_next ]] <<lsr_next>>
			ListResult [[ p * ]]
	}

ListResult [[P struct ds_list_result *]]
	::=
	CHOICE <E<1>><D<0>>
	{
		ListResultData [[p * ]] ,
		SEQUENCE [[ T struct ds_list_result * $ *]]
		{
			ListResultData [[p * ]] ,
			AlgorithmIdentifier [[p parm->lsr_common.cr_alg]],
			BIT STRING [[ x parm->lsr_common.cr_tmp $ parm->lsr_common.cr_len ]]
		}
	}

SearchArgumentData [[P struct ds_search_arg *]]
	::=
	SET
	{
	%D{
	(*parm)->sra_eis.eis_allattributes = TRUE;
	(*parm)->sra_eis.eis_infotypes = EIS_ATTRIBUTESANDVALUES;
	(*parm)->sra_common.ca_servicecontrol.svc_prio = SVC_PRIO_MED;
	(*parm)->sra_common.ca_servicecontrol.svc_timelimit = SVC_NOTIMELIMIT;
	(*parm)->sra_common.ca_servicecontrol.svc_sizelimit = SVC_NOSIZELIMIT;
	(*parm)->sra_common.ca_servicecontrol.svc_scopeofreferral = SVC_REFSCOPE_NONE;
	(*parm)->sra_common.ca_aliased_rdns = CA_NO_ALIASDEREFERENCED;
	%}
	baseObject
		[0] Name [[p parm->sra_baseobject]],
	subset
		[1] INTEGER [[i parm->sra_subset]]
		{
		baseObject(0) ,
		oneLevel(1) ,
		wholeSubtree(2)
		}
		DEFAULT baseObject,
	filter
		[2] Filter [[p parm->sra_filter]]
		    OPTIONAL,
	searchAliases
		[3] BOOLEAN [[b parm->sra_searchaliases]]
		    DEFAULT TRUE ,
	selection
		[4] EntryInformationSelection [[p &parm->sra_eis]]
		    -- DEFAULT {},
		    OPTIONAL <D<0>>
			     <E< (
			     (parm->sra_eis.eis_allattributes != TRUE) ||
			     (parm->sra_eis.eis_infotypes != EIS_ATTRIBUTESANDVALUES)
			     ) >>,
		[30] ServiceControls [[p &parm->sra_common.ca_servicecontrol]]
		     -- DEFAULT {},
		    OPTIONAL <D<0>>
		    <E< (
		    (parm->sra_common.ca_servicecontrol.svc_options != 0) ||
		    (parm->sra_common.ca_servicecontrol.svc_prio != SVC_PRIO_MED) ||
		    (parm->sra_common.ca_servicecontrol.svc_timelimit != SVC_NOTIMELIMIT) ||
		    (parm->sra_common.ca_servicecontrol.svc_sizelimit != SVC_NOSIZELIMIT) ||
		    (parm->sra_common.ca_servicecontrol.svc_scopeofreferral != SVC_REFSCOPE_NONE)
		    ) >>,

		[29] SecurityParameters [[p parm->sra_common.ca_security]]
		     -- DEFAULT {} ,
		     OPTIONAL,
	requestor
		[28] DistinguishedName [[p  parm->sra_common.ca_requestor]]
		     OPTIONAL,
		[27] OperationProgress [[p &parm->sra_common.ca_progress]]
		     OPTIONAL <D<0>>
		     <E<parm->sra_common.ca_progress.op_resolution_phase > 1>>,
	aliasedRDNs
		[26] INTEGER [[i parm->sra_common.ca_aliased_rdns]]
		     OPTIONAL <E<parm->sra_common.ca_aliased_rdns != CA_NO_ALIASDEREFERENCED>><D<0>>
		,
	extensions
		[25] SET OF [[ T struct extension * $ parm->sra_common.ca_extensions]] 
		     <<ext_next>> Extension [[p *]] 
		     OPTIONAL
	}

SearchArgument [[P struct ds_search_arg *]]
	::=
	CHOICE <D<0>>
	<E<(parm->sra_common.ca_sig == (struct signature *) 0)? 1:2>>
	{
		SearchArgumentData [[p * ]] ,
		SEQUENCE [[ T struct ds_search_arg * $ * ]]
		{
			SearchArgumentData [[p * ]] ,
			TAlgorithmIdentifier [[p parm->sra_common.ca_sig ]],
			TBitString [[ p parm->sra_common.ca_sig ]]
		}
	}


SearchResultData [[P struct ds_search_result *]]
	::=
	CHOICE <D<(*parm)->srr_correlated>>
	<E<((parm->srr_correlated == FALSE) ? 2 : 1)>>
	{
	searchInfo
		SET [[ T struct ds_search_unit * $ srr_un.srr_unit ]]
		{
			DistinguishedName [[p srr_object]]
			    OPTIONAL,
		entries
			[0] SET OF [[ T struct entrystruct * $ srr_entries ]]
			    <<ent_next>> EntryInformation [[p *]],

	%D{
		(*parm)->srr_poq.poq_limitproblem = LSR_NOLIMITPROBLEM;
	%}
		partialOutcomeQualifier
			[2] PartialOutcomeQualifier [[p &parm->srr_poq]]
			    OPTIONAL <E<
				     ((parm->srr_poq.poq_limitproblem != LSR_NOLIMITPROBLEM) || 
				     (parm->srr_poq.poq_cref != NULLCONTINUATIONREF)) 
				     >><D<0>>,
			[30] SecurityParameters [[p srr_common.cr_security ]]
			    OPTIONAL ,
		performer
			[29] DistinguishedName [[p srr_common.cr_requestor]]
			    OPTIONAL,
		aliasDereferenced
			[28] BOOLEAN [[b srr_common.cr_aliasdereferenced]]
			     DEFAULT FALSE
		},
	uncorrelatedSearchInfo
		[0] SET OF [[ T struct ds_search_result * $ srr_un.srr_parts ]]
		    <<srr_next>> SearchResult [[p *]]
	}
%D{
	if ((*parm)->srr_correlated == 2)
	   (*parm)->srr_correlated = 0;
%}