das.py

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

-- Pespy temp
-- If uncorrelated this will fail
SAlgorithmIdentifier [[P struct ds_search_unit *]]
	::= AlgorithmIdentifier [[p srr_common.cr_alg]]

SBitString [[P struct ds_search_unit *]]
	::= BIT STRING [[ x srr_common.cr_tmp $ srr_common.cr_len ]]

SearchResult [[P struct ds_search_result *]]
	::=
	CHOICE <E<1>><D<0>>
	{
		SearchResultData [[p * ]] ,
		SEQUENCE [[ T struct ds_search_result * $ *]]
		{
			SearchResultData [[p * ]] ,
			SAlgorithmIdentifier [[p srr_un.srr_unit ]],
			SBitString [[p srr_un.srr_unit]]
		}
	}

AddEntryArgumentData [[P struct ds_addentry_arg *]]
	::=
	SET
	{
	%D{
	(*parm)->ada_common.ca_servicecontrol.svc_prio = SVC_PRIO_MED;
	(*parm)->ada_common.ca_servicecontrol.svc_timelimit = SVC_NOTIMELIMIT;
	(*parm)->ada_common.ca_servicecontrol.svc_sizelimit = SVC_NOSIZELIMIT;
	(*parm)->ada_common.ca_servicecontrol.svc_scopeofreferral = SVC_REFSCOPE_NONE;
	(*parm)->ada_common.ca_aliased_rdns = CA_NO_ALIASDEREFERENCED;
	%}
	object
		[0] DistinguishedName [[p ada_object]],
	entry
		[1] SET OF [[ T struct attrcomp * $ ada_entry ]] <<attr_link>> 
		    Attribute [[p *]],
		[30] ServiceControls [[p &parm->ada_common.ca_servicecontrol]]
		     -- DEFAULT {},
		    OPTIONAL <D<0>>
		    <E< (
		    (parm->ada_common.ca_servicecontrol.svc_options != 0) ||
		    (parm->ada_common.ca_servicecontrol.svc_prio != SVC_PRIO_MED) ||
		    (parm->ada_common.ca_servicecontrol.svc_timelimit != SVC_NOTIMELIMIT) ||
		    (parm->ada_common.ca_servicecontrol.svc_scopeofreferral != SVC_REFSCOPE_NONE)
		    ) >>,

		[29] SecurityParameters [[p parm->ada_common.ca_security]]
		     -- DEFAULT {} ,
		     OPTIONAL,
	requestor
		[28] DistinguishedName [[p  parm->ada_common.ca_requestor]]
		     OPTIONAL,
		[27] OperationProgress [[p &parm->ada_common.ca_progress]]
		     OPTIONAL <D<0>>
		     <E<parm->ada_common.ca_progress.op_resolution_phase > 1>>,
	aliasedRDNs
		[26] INTEGER [[i parm->ada_common.ca_aliased_rdns]]
		     OPTIONAL <E<parm->ada_common.ca_aliased_rdns != CA_NO_ALIASDEREFERENCED>><D<0>> ,
	extensions
		[25] SET OF [[ T struct extension * $ parm->ada_common.ca_extensions]]
		<<ext_next>> Extension [[p *]] OPTIONAL
	}
	    %D{
		   /* Order attribute*/
		   
		   Attr_Sequence as;
		   Attr_Sequence as_next;
		   Attr_Sequence newas = NULLATTR;
		   
		   for (as=(*parm)->ada_entry; as != NULLATTR; as = as_next) {
		       as_next = as->attr_link;
		       as->attr_link = NULLATTR;
		       newas = as_merge (newas,as);
		   }
		   (*parm)->ada_entry = newas;
	    %}

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

AddEntryResult ::= NULL

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

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

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

RemoveEntryResult ::= NULL

ModifyEntryArgumentData [[P struct ds_modifyentry_arg *]]
	::=
	SET
	{
	%D{
	(*parm)->mea_common.ca_servicecontrol.svc_prio = SVC_PRIO_MED;
	(*parm)->mea_common.ca_servicecontrol.svc_timelimit = SVC_NOTIMELIMIT;
	(*parm)->mea_common.ca_servicecontrol.svc_sizelimit = SVC_NOSIZELIMIT;
	(*parm)->mea_common.ca_servicecontrol.svc_scopeofreferral = SVC_REFSCOPE_NONE;
	(*parm)->mea_common.ca_aliased_rdns = CA_NO_ALIASDEREFERENCED;
	%}
	object
		[0] DistinguishedName [[p parm->mea_object]],
	changes
		[1] SEQUENCE OF [[ T struct entrymod * $ mea_changes]] <<em_next>>
			EntryModification [[p *]],
		[30] ServiceControls [[p &parm->mea_common.ca_servicecontrol]]
		     -- DEFAULT {} ,
		    OPTIONAL <D<0>>
		    <E< (
		    (parm->mea_common.ca_servicecontrol.svc_options != 0) ||
		    (parm->mea_common.ca_servicecontrol.svc_prio != SVC_PRIO_MED) ||
		    (parm->mea_common.ca_servicecontrol.svc_timelimit != SVC_NOTIMELIMIT) ||
		    (parm->mea_common.ca_servicecontrol.svc_scopeofreferral != SVC_REFSCOPE_NONE)
		    ) >>,

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

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

ModifyEntryResult ::= NULL

ModifyRDNArgumentData [[P struct ds_modifyrdn_arg *]]
	::=
	SET
	{
	%D{
	(*parm)->mra_common.ca_servicecontrol.svc_prio = SVC_PRIO_MED;
	(*parm)->mra_common.ca_servicecontrol.svc_timelimit = SVC_NOTIMELIMIT;
	(*parm)->mra_common.ca_servicecontrol.svc_sizelimit = SVC_NOSIZELIMIT;
	(*parm)->mra_common.ca_servicecontrol.svc_scopeofreferral = SVC_REFSCOPE_NONE;
	(*parm)->mra_common.ca_aliased_rdns = CA_NO_ALIASDEREFERENCED;
	%}
	object
		[0] DistinguishedName [[p mra_object]],
	newRDN
		[1] RelativeDistinguishedName [[p mra_newrdn]],
	deleteRDN
		[2] BOOLEAN [[b deleterdn]]
		     DEFAULT FALSE,
		[30] ServiceControls [[p &parm->mra_common.ca_servicecontrol]]
		     -- DEFAULT {},
		    OPTIONAL <D<0>>
		    <E< (
		    (parm->mra_common.ca_servicecontrol.svc_options != 0) ||
		    (parm->mra_common.ca_servicecontrol.svc_prio != SVC_PRIO_MED) ||
		    (parm->mra_common.ca_servicecontrol.svc_timelimit != SVC_NOTIMELIMIT) ||
		    (parm->mra_common.ca_servicecontrol.svc_scopeofreferral != SVC_REFSCOPE_NONE)
		    ) >>,

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

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

ModifyRDNResult ::= NULL

DirectoryBindError [[P struct ds_bind_error *]]
	::=
	SET
	{
		%E{
			if (parm->dbe_version == DBA_VERSION_V1988) {
			   parm->dbe_vlen = 1;
			   parm->dbe_vtmp = int2strb_alloc(parm->dbe_version,1);
			} else
			  return NOTOK;
		%}
	%D{
	   (*parm)->dbe_version = DBA_VERSION_V1988;
	%}
		versions
			[0] Versions [[x dbe_vtmp $ dbe_vlen ]]
			    %E{
			    if (parm->dbe_vtmp)
				free (parm->dbe_vtmp);
			    %}
			    %D{
			    if ((*parm)->dbe_vlen) {
				(*parm)->dbe_version = strb2int((*parm)->dbe_vtmp ,(*parm)->dbe_vlen);
				free ((*parm)->dbe_vtmp);
			    }
			    %}
			    DEFAULT {v1988},
		    
		CHOICE [[T struct ds_bind_error * $ *]] <<dbe_type>>
		{
		serviceError
			[1] ServiceProblem [[i dbe_value]],
		securityError
			[2] SecurityProblem [[i dbe_value]]
		}
	}

AbandonFailedParm [[P struct DSE_abandon_fail *]]
	::=
	SET
	{
	problem
		[0] AbandonProblem [[i DSE_ab_problem]],
	operation
		[1] TInvokeID [[i DSE_ab_invokeid]]
	}

AttributeErrorParm [[P struct DSE_attribute *]]
	::=
	SET
	{
	object
		[0] Name [[p parm->DSE_at_name]],
	problems
		[1] SET OF [[ T struct DSE_at_problem * $ &parm->DSE_at_plist ]] << dse_at_next >>
			SEQUENCE [[ T struct DSE_at_problem * $ *]]
			{
			problem
				[0] AttributeProblem [[i DSE_at_what]],
			type
				[1] AttributeType [[p DSE_at_type]],
			value
				[2] AttributeValue [[p DSE_at_value]]
				    %D{
				    extern AttrT_print ();
				    extern LLog * log_dsap;

				    if ((*parm)->DSE_at_value)
				       if (AttrV_decode ((*parm)->DSE_at_type,
						(*parm)->DSE_at_value) != OK) {
		                          pslog (log_dsap,LLOG_EXCEPTIONS,
				          "AttrV_decode failed",
				          AttrT_print, (caddr_t) (*parm)->DSE_at_type);
				          return NOTOK;
				       }
				    %}
				    OPTIONAL
			}
	}

NameErrorParm [[P struct DSE_name *]]
	::=
	SET
	{
	problem
		[0] NameProblem [[i DSE_na_problem]],
	matched
		[1] Name [[p DSE_na_matched]]
	}

ReferralParm [[P struct DSE_referral *]]
	::=
	SET
	{
	candidate
		[0] ContinuationReference [[p DSE_ref_candidates]]
	}

SecurityErrorParm [[P struct DSE_security *]]
	::=
	SET
	{
	problem
		[0] SecurityProblem [[i DSE_sc_problem]]
	}

ServiceErrorParm [[P struct DSE_service *]]
	::=
	SET
	{
	problem
		[0] ServiceProblem [[i DSE_sv_problem]]
	}

UpdateErrorParm [[P struct DSE_update *]]
	::=
	SET
	{
	problem
		[0] UpdateProblem [[i DSE_up_problem]]
	}


END


%{

/* same as int2strb but with a real buffer */
char   *int2strb_alloc (n, len)
register int    n;
int     len;
{
    register int    i;
    static char *buffer;

    buffer = calloc (1,sizeof (int) + 1);

    for (i = 0; i < len; i++)
	if (n & (1 << i))
	    buffer[i / 8] |= (1 << (7 - (i % 8)));

    return buffer;
}


#ifndef lint

#undef encode_DAS_TokenToSign
int	encode_DAS_TokenToSign(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_TokenToSign *parm;
{
  return (enc_f(_ZTokenToSignDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef encode_DAS_ReadArgumentData
int	encode_DAS_ReadArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_ReadArgumentData *parm;
{
  return (enc_f(_ZReadArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef encode_DAS_CompareArgumentData
int	encode_DAS_CompareArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_CompareArgumentData *parm;
{
  return (enc_f(_ZCompareArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}
#undef encode_DAS_ListArgumentData
int	encode_DAS_ListArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_ListArgumentData *parm;
{
  return (enc_f(_ZListArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef encode_DAS_SearchArgumentData
int	encode_DAS_SearchArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_SearchArgumentData *parm;
{
  return (enc_f(_ZSearchArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef encode_DAS_AddEntryArgumentData
int	encode_DAS_AddEntryArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_AddEntryArgumentData *parm;
{
  return (enc_f(_ZAddEntryArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef encode_DAS_RemoveEntryArgumentData
int	encode_DAS_RemoveEntryArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_RemoveEntryArgumentData *parm;
{
  return (enc_f(_ZRemoveEntryArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef encode_DAS_ModifyEntryArgumentData
int	encode_DAS_ModifyEntryArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_ModifyEntryArgumentData *parm;
{
  return (enc_f(_ZModifyEntryArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#undef encode_DAS_ModifyRDNArgumentData
int	encode_DAS_ModifyRDNArgumentData(pe, top, len, buffer, parm)
PE     *pe;
int	top,
	len;
char   *buffer;
struct type_DAS_ModifyRDNArgumentData *parm;
{
  return (enc_f(_ZModifyRDNArgumentDataDAS, &_ZDAS_mod, pe, top, len, buffer,
		(char *) parm));
}

#endif 

%}