asn_ext.c

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

#ifdef DEBUG
		(void) testdebug (p116, "type");
#endif

		if (decode_IF_AttributeType (p116, 1, (int *)0, NULLVP, &subs_next->fi_sub_type) == NOTOK)
		    return NOTOK;
	    }
	}
	else {
	    advise (NULLCP, "substrings %stype element", PEPY_ERR_MISSING);
	    return NOTOK;
	}

    }

    {
	register PE p117;

	if ((p117 = (p113 != p115 ? next_member (p113, p115) : first_member (p113))) != NULLPE) {
	    p115 = p117;

	    {	/* strings */
		register PE p118;

#ifdef DEBUG
		(void) testdebug (p117, "strings");
#endif

		if (p117 -> pe_class != PE_CLASS_UNIV
			|| p117 -> pe_form != PE_FORM_CONS
			|| p117 -> pe_id != PE_CONS_SEQ) {
		    advise (NULLCP, "strings bad class/form/id: %s/%d/0x%x",
			    pe_classlist[p117 -> pe_class], p117 -> pe_form, p117 -> pe_id);
		    return NOTOK;
		}

		if ((p118 = prim2seq (p117)) == NULLPE) {
		    advise (NULLCP, "strings %s%s", PEPY_ERR_BAD_SEQ,
			    pe_error (p117 -> pe_errno));
		    return NOTOK;
		}
		p117 = p118;

		for (p118 = first_member (p117); p118; p118 = next_member (p117, p118)) {
		    {
#ifdef DEBUG
			(void) testdebug (p118, "element");
#endif
			av_next = AttrV_alloc();
			av_next->av_syntax = 0;

			switch (PE_ID (p118 -> pe_class, p118 -> pe_id)) {
			    case PE_ID (PE_CLASS_CONT, 0):	/* initial */
				{
				    register PE p119 = p118;

				    {	/* initial TAG PULLUP */
					register PE p120;

					if ((p120 = prim2set (p119)) == NULLPE) {
					    advise (NULLCP, "initial %sinitial: %s", PEPY_ERR_BAD,
						    pe_error (p119 -> pe_errno));
					    return NOTOK;
					}
					if (p120 -> pe_cardinal != 1) {
					    advise (NULLCP, "initial %s initial: %d", PEPY_ERR_TOO_MANY_TAGGED,
						    p120 -> pe_cardinal);
					    return NOTOK;
					}
					p119 = first_member (p120);
				    }
				    {
#ifdef DEBUG
					(void) testdebug (p119, "initial");
#endif

/*
					if (decode_IF_AttributeValue (p119, 1, NULLINTP, NULLVP, &av_next) == NOTOK)
					    return NOTOK;
*/
					av_next->av_struct = (caddr_t)p119;
					p119->pe_refcnt++;
					{

				if (AttrV_decode (subs_next->fi_sub_type,av_next) != OK) {
					LLOG (log_dsap,LLOG_EXCEPTIONS,("invalid initial value"));
					return NOTOK;
				}
				(*avs_initial) = avs_comp_new(av_next);
				avs_initial = &((*avs_initial)->avseq_next);
				(*avs_initial) = NULLAV;

					}
				    }
				}
				break;
			    case PE_ID (PE_CLASS_CONT, 1):	/* any */
				{
				    register PE p121 = p118;

				    {	/* any TAG PULLUP */
					register PE p122;

					if ((p122 = prim2set (p121)) == NULLPE) {
					    advise (NULLCP, "any %sany: %s", PEPY_ERR_BAD,
						    pe_error (p121 -> pe_errno));
					    return NOTOK;
					}
					if (p122 -> pe_cardinal != 1) {
					    advise (NULLCP, "any %s any: %d", PEPY_ERR_TOO_MANY_TAGGED,
						    p122 -> pe_cardinal);
					    return NOTOK;
					}
					p121 = first_member (p122);
				    }
				    {
#ifdef DEBUG
					(void) testdebug (p121, "any");
#endif
/*
					if (decode_IF_AttributeValue (p121, 1, NULLINTP, NULLVP, &av_next) == NOTOK)
					    return NOTOK;
*/
					av_next->av_struct = (caddr_t)p121;
					p121->pe_refcnt++;
					{

				if (AttrV_decode (subs_next->fi_sub_type,av_next) != OK) {
					LLOG (log_dsap,LLOG_EXCEPTIONS,("invalid any value"));
					return NOTOK;
				}
				(*avs_any) = avs_comp_new(av_next);
				avs_any = &((*avs_any)->avseq_next);
				(*avs_any) = NULLAV;

					}
				    }
				}
				break;
			    case PE_ID (PE_CLASS_CONT, 2):	/* final */
				{
				    register PE p123 = p118;

				    {	/* final TAG PULLUP */
					register PE p124;

					if ((p124 = prim2set (p123)) == NULLPE) {
					    advise (NULLCP, "final %sfinal: %s", PEPY_ERR_BAD,
						    pe_error (p123 -> pe_errno));
					    return NOTOK;
					}
					if (p124 -> pe_cardinal != 1) {
					    advise (NULLCP, "final %s final: %d", PEPY_ERR_TOO_MANY_TAGGED,
						    p124 -> pe_cardinal);
					    return NOTOK;
					}
					p123 = first_member (p124);
				    }
				    {
#ifdef DEBUG
					(void) testdebug (p123, "final");
#endif
/*

					if (decode_IF_AttributeValue (p123, 1, NULLINTP, NULLVP, &av_next) == NOTOK)
					    return NOTOK;
*/
					av_next->av_struct = (caddr_t)p123;
					p123->pe_refcnt++;

					{

				if (AttrV_decode (subs_next->fi_sub_type,av_next) != OK) {
					LLOG (log_dsap,LLOG_EXCEPTIONS,("invalid final value"));
					return NOTOK;
				}
				(*avs_final) = avs_comp_new(av_next);
				avs_final = &((*avs_final)->avseq_next);
				(*avs_final) = NULLAV;

					}
				    }
				}
				break;

			    default:
				advise (NULLCP, "element %s%s/%d/0x%x", PEPY_ERR_UNKNOWN_CHOICE,
					pe_classlist[p118 -> pe_class], p118 -> pe_form, p118 -> pe_id);
				return NOTOK;
			}
		    }
		}
	    }
	}
	else {
	    advise (NULLCP, "substrings %sstrings element", PEPY_ERR_MISSING);
	    return NOTOK;
	}

    }


    if (p113 -> pe_cardinal > 2) {
	advise (NULLCP, "substrings %s(2): %d", PEPY_ERR_TOO_MANY_ELEMENTS,
		p113 -> pe_cardinal);
	return NOTOK;
    }
}
	return OK;
}

substring_free (parm)
struct filter_item *parm;
{
	avs_free (parm->UNSUB.fi_sub_initial);
	avs_free (parm->UNSUB.fi_sub_any);
	avs_free (parm->UNSUB.fi_sub_final);

	return OK;
}



/* TreeStructureSyntax encode */
/*
 *
 *TreeStructureSyntax [[P struct tree_struct *]]
 *%{
 *OID     oid_tmp;
 *int	do_once;
 *%}
 *        ::=
 *        %{
 *                DLOG(log_dsap, LLOG_PDUS, ("About to encode TreeStructureSyntax"));
 *		if (parm->tree_object == NULLOBJECTCLASS) {
 *	                DLOG(log_dsap, LLOG_DEBUG, ("NULL OID in tree structure"));
 *			oid_tmp = NULLOID;
 *		} else {
 *	                oid_tmp = oid_cpy(parm->tree_object->oc_ot.ot_oid);
 *	                DLOG(log_dsap, LLOG_DEBUG, ("oc encodes as oid: %s", sprintoid(oid_tmp)));
 *		}
 *        %}
 *        SET
 *	{
 *	mandatoryObjectClasses
 *		[1] SET OF
 *		%{
 *	                DLOG(log_dsap, LLOG_DEBUG, ("Another mandatory oc"));
 *		%}
 *		<<do_once = 1; do_once != 0; do_once = 0>>
 *                	OBJECT IDENTIFIER [[O oid_tmp]] ,
 *	optionalObjectClasses
 *		[2] SET OF
 *                	OBJECT IDENTIFIER
 *		    -- OPTIONAL <<FALSE>> ,
 *		    OPTIONAL ,
 *	permittedRDNs
 *		[3] SET OF
 *			SET OF
 *				AttributeType [[p NULLAttrT]]
 *	}
 *        %{
 *		if(oid_tmp != NULLOID)
 *		    oid_free (oid_tmp);
 *                DLOG(log_dsap, LLOG_PDUS, ("Done encode TreeStructureSyntax"));
 *        %}
 *
 */

treestruct_encode (parm,pe)
struct tree_struct * parm;
PE * pe;
{
OID     oid_tmp;
int	do_once;

    PE	p23_z = NULLPE;
    register PE *p23 = &p23_z;

    if (((*pe) = pe_alloc (PE_CLASS_UNIV, PE_FORM_CONS, PE_CONS_SET)) == NULLPE) {
	advise (NULLCP, "TreeStructureSyntax: %s", PEPY_ERR_NOMEM);
	return NOTOK;
    }
    {

		if (parm->tree_object == NULLOBJECTCLASS) {
			DLOG(log_dsap, LLOG_DEBUG, ("NULL OID in tree structure"));
			oid_tmp = NULLOID;
		} else {
			oid_tmp = oid_cpy(parm->tree_object->oc_ot.ot_oid);
			DLOG(log_dsap, LLOG_DEBUG, ("oc encodes as oid: %s", sprintoid(oid_tmp)));
		}

    }
    (*p23) = NULLPE;

    {
	PE	p24 = NULLPE;
	PE	p25_z = NULLPE;
	register PE *p25 = &p25_z;

	if (((*p23) = pe_alloc (PE_CLASS_UNIV, PE_FORM_CONS, PE_CONS_SET)) == NULLPE) {
	    advise (NULLCP, "mandatoryObjectClasses: %s", PEPY_ERR_NOMEM);
	    return NOTOK;
	}
	for (do_once = 1; do_once != 0; do_once = 0) {
	    {

			DLOG(log_dsap, LLOG_DEBUG, ("Another mandatory oc"));

	    }
	    {
		register OID p26;

		p26 = oid_tmp;
		if (p26 == NULLOID) {
		    advise (NULLCP, "member %s", PEPY_ERR_INIT_FAILED);
		    return NOTOK;
		}
		if (((*p25) = obj2prim (p26, PE_CLASS_UNIV, PE_PRIM_OID)) == NULLPE) {
		    advise (NULLCP, "member: %s", PEPY_ERR_NOMEM);
		    return NOTOK;
		}

#ifdef DEBUG
		(void) testdebug ((*p25), "member");
#endif

	    }
	    (void)set_addon ((*p23), p24, (*p25));
	    p24 = (*p25);
	}

#ifdef DEBUG
	(void) testdebug ((*p23), "mandatoryObjectClasses");
#endif

	{	/* mandatoryObjectClasses TAG PUSHDOWN */
	    PE p27_z;
	    register PE *p27 = &p27_z;

	    if ((*p27 = pe_alloc (PE_CLASS_CONT, PE_FORM_CONS, 1)) == NULLPE) {
		advise (NULLCP, "mandatoryObjectClasses: %s", PEPY_ERR_NOMEM);
		return NOTOK;
	    }
	    (*p27) -> pe_cons = (*p23);
	    (*p23) = *p27;
	}
    }
    if ((*p23) != NULLPE)
	if (set_add ((*pe), (*p23)) == NOTOK) {
	    advise (NULLCP, "TreeStructureSyntax %s%s", PEPY_ERR_BAD_SET,
		    pe_error ((*pe) -> pe_errno));
	    return NOTOK;
	}
    (*p23) = NULLPE;

    if ((*p23) != NULLPE)
	if (set_add ((*pe), (*p23)) == NOTOK) {
	    advise (NULLCP, "TreeStructureSyntax %s%s", PEPY_ERR_BAD_SET,
		    pe_error ((*pe) -> pe_errno));
	    return NOTOK;
	}
    (*p23) = NULLPE;

    {
	if (((*p23) = pe_alloc (PE_CLASS_UNIV, PE_FORM_CONS, PE_CONS_SET)) == NULLPE) {
	    advise (NULLCP, "permittedRDNs: %s", PEPY_ERR_NOMEM);
	    return NOTOK;
	}

#ifdef DEBUG
	(void) testdebug ((*p23), "permittedRDNs");
#endif

	{	/* permittedRDNs TAG PUSHDOWN */
	    PE p30_z;
	    register PE *p30 = &p30_z;

	    if ((*p30 = pe_alloc (PE_CLASS_CONT, PE_FORM_CONS, 3)) == NULLPE) {
		advise (NULLCP, "permittedRDNs: %s", PEPY_ERR_NOMEM);
		return NOTOK;
	    }
	    (*p30) -> pe_cons = (*p23);
	    (*p23) = *p30;
	}
    }
    if ((*p23) != NULLPE)
	if (set_add ((*pe), (*p23)) == NOTOK) {
	    advise (NULLCP, "TreeStructureSyntax %s%s", PEPY_ERR_BAD_SET,
		    pe_error ((*pe) -> pe_errno));
	    return NOTOK;
	}

#ifdef DEBUG
    (void) testdebug ((*pe), "Quipu.TreeStructureSyntax");
#endif

    {

		if(oid_tmp != NULLOID)
		    oid_free (oid_tmp);

    }

	return OK;
}

/* TreeStructSyntax decode */
/*
 *
 *TreeStructureSyntax [[P struct tree_struct **]]
 *%{
 *AttributeType	  at_tmp;
 *OID     oid_tmp;
 *int	is_first;
 *objectclass * oc_add();
 *%}
 *        ::=
 *        %{
 *                DLOG(log_dsap, LLOG_PDUS, ("About to decode TreeStructureSyntax"));
 *		is_first = 1;
 *        %}
 *        SET
 *	{
 *	mandatoryObjectClasses