asn_ext.c

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

/* asn_ext.c - ASN.1 code pepsy can't quite do yet */

#ifndef	lint
static char *rcsid = "$Header: /xtel/isode/isode/dsap/x500as/RCS/asn_ext.c,v 9.0 1992/06/16 12:14:33 isode Rel $";
#endif

/* 
 * $Header: /xtel/isode/isode/dsap/x500as/RCS/asn_ext.c,v 9.0 1992/06/16 12:14:33 isode Rel $
 *
 *
 * $Log: asn_ext.c,v $
 * Revision 9.0  1992/06/16  12:14:33  isode
 * Release 8.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.
 *
 */


/* LINTLIBRARY */

#include "quipu/util.h"
#include "quipu/entry.h"
#include "quipu/common.h"
#include "quipu/dsargument.h"
#include "quipu/turbo.h"
#include "IF-types.h"
#include "Quipu-types.h"

#define	advise	PY_advise

extern	LLog	* log_dsap;


/* Encoding substring filters */
/*
 *
 *        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;
 *                                        %}
 *                                }
 *                                %{
 *                                %}
 *                        %{
 *                        %}
 *                }
 *
 */


substring_encode (parm,pe)
struct filter_item *parm;
PE *pe;
{
int		subs_type;
AV_Sequence	avs_temp;
Filter_Substrings	*subs_temp;

PE	p91_z = NULLPE;
register PE *p91 = &p91_z;

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

		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;
		    }
		}

	(*p91) = NULLPE;

	    if (encode_IF_AttributeType (p91, 0, 0, NULLCP, subs_temp->fi_sub_type) == NOTOK)
		return NOTOK;


	if ((*p91) != NULLPE)
	    if (seq_add ((*pe), (*p91), -1) == NOTOK) {
		advise (NULLCP, "substrings %s%s", PEPY_ERR_BAD_SEQ,
			pe_error ((*pe) -> pe_errno));
		return NOTOK;
	    }
	(*p91) = NULLPE;

	{	/* strings */
	    PE	p92 = NULLPE;
	    PE	p93_z = NULLPE;
	    register PE *p93 = &p93_z;

	    if (((*p91) = pe_alloc (PE_CLASS_UNIV, PE_FORM_CONS, PE_CONS_SEQ)) == NULLPE) {
		advise (NULLCP, "strings: %s", PEPY_ERR_NOMEM);
		return NOTOK;
	    }
	    for (; avs_temp != NULLAV;) {
		{
		    int	p94;

		    switch (p94 = (subs_type)) {
			case 1:	/* initial */
			    {
				if (encode_IF_AttributeValue (p93, 0, 0, NULLCP, &avs_temp->avseq_av) == NOTOK)
				    return NOTOK;


				{

					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;
					    }
					}

				}
				{	/* initial TAG PUSHDOWN */
				    PE p95_z;
				    register PE *p95 = &p95_z;

				    if ((*p95 = pe_alloc (PE_CLASS_CONT, PE_FORM_CONS, 0)) == NULLPE) {
					advise (NULLCP, "initial: %s", PEPY_ERR_NOMEM);
					return NOTOK;
				    }
				    (*p95) -> pe_cons = (*p93);
				    (*p93) = *p95;
				}
			    }
			    break;
			case 2:	/* any */
			    {
				if (encode_IF_AttributeValue (p93, 0, 0, NULLCP, &avs_temp->avseq_av) == NOTOK)
				    return NOTOK;


				{

					if((avs_temp = avs_temp->avseq_next) == NULLAV)
					{
					    ++subs_type;
					    avs_temp = subs_temp->fi_sub_final;
					}

				}
				{	/* any TAG PUSHDOWN */
				    PE p96_z;
				    register PE *p96 = &p96_z;

				    if ((*p96 = pe_alloc (PE_CLASS_CONT, PE_FORM_CONS, 1)) == NULLPE) {
					advise (NULLCP, "any: %s", PEPY_ERR_NOMEM);
					return NOTOK;
				    }
				    (*p96) -> pe_cons = (*p93);
				    (*p93) = *p96;
				}
			    }
			    break;
			case 3:	/* final */
			    {
				if (encode_IF_AttributeValue (p93, 0, 0, NULLCP, &avs_temp->avseq_av) == NOTOK)
				    return NOTOK;

					avs_temp = avs_temp->avseq_next;
				{	/* final TAG PUSHDOWN */
				    PE p97_z;
				    register PE *p97 = &p97_z;

				    if ((*p97 = pe_alloc (PE_CLASS_CONT, PE_FORM_CONS, 2)) == NULLPE) {
					advise (NULLCP, "final: %s", PEPY_ERR_NOMEM);
					return NOTOK;
				    }
				    (*p97) -> pe_cons = (*p93);
				    (*p93) = *p97;
				}
			    }
			    break;

			default:
			    advise (NULLCP, "element %s%d", PEPY_ERR_INVALID_CHOICE, 
				    p94);
			    return NOTOK;
		    }


		}
		(void) seq_addon ((*p91), p92, (*p93));
		p92 = (*p93);
	    }

	}

	if ((*p91) != NULLPE)
	    if (seq_add ((*pe), (*p91), -1) == NOTOK) {
		advise (NULLCP, "substrings %s%s", PEPY_ERR_BAD_SEQ,
			pe_error ((*pe) -> pe_errno));
		return NOTOK;
	    }

/*
 *	{	/* substrings TAG PUSHDOWN */
/*	    PE p98_z;
 *	    register PE *p98 = &p98_z;
 *
 *	    if ((*p98 = pe_alloc (PE_CLASS_CONT, PE_FORM_CONS, 1)) == NULLPE) {
 *		advise (NULLCP, "substrings: %s", PEPY_ERR_NOMEM);
 *		return NOTOK;
 *	    }
 *	    (*p98) -> pe_cons = (*pe);
 *	    (*pe) = *p98;
 *	}
 */

	return OK;
}


/*  substring decoding
 *
 *        substrings
 *                %{
 *                        parm->fi_type = FILTERITEM_SUBSTRINGS;
 *                        subs_next = &(parm->fi_un.fi_un_substrings);
 *                        subs_next->fi_sub_initial = NULLAV;
 *                        subs_next->fi_sub_any = NULLAV;
 *                        subs_next->fi_sub_final = NULLAV;
 *			avs_initial = &(subs_next->fi_sub_initial);
 *			avs_any = &(subs_next->fi_sub_any);
 *			avs_final = &(subs_next->fi_sub_final);
 *                %}
 *                [1] SEQUENCE
 *                {
 *                type
 *                        AttributeType [[p &subs_next->fi_sub_type]]
 *                        %{
 *                        %} ,
 *                strings
 *                        SEQUENCE OF
 *                        %{
 *				av_next = AttrV_alloc();
 *                        %}
 *                                CHOICE
 *                                {
 *                                initial
 *                                        [0] AttributeValue [[p av_next]]
 *                                        %{
 *						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;
 *                                        %} ,
 *                                any
 *                                        [1] AttributeValue [[p av_next]]
 *                                        %{
 *						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;
 *                                        %} ,
 *                                final
 *                                        [2] AttributeValue [[p av_next]]
 *                                        %{
 *						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;
 *                                        %}
 *                                }
 *                                %{
 *                                %}
 *                        %{
 *                        %}
 *                }
 *
 *
 */


substring_decode (pparm,pe)
struct filter_item ** pparm;
PE pe;
{
AV_Sequence	* avs_initial;
AV_Sequence	* avs_any;
AV_Sequence	* avs_final;
AttributeValue	av_next;
Filter_Substrings	*subs_next;
struct filter_item *parm;

register PE p113 = pe;

parm = *pparm;

#ifdef NOTANYMORE
{	/* substrings TAG PULLUP */
    register PE p114;

    if ((p114 = prim2set (p113)) == NULLPE) {
	advise (NULLCP, "substrings %ssubstrings: %s", PEPY_ERR_BAD,
		pe_error (p113 -> pe_errno));
	return NOTOK;
    }
    if (p114 -> pe_cardinal != 1) {
	advise (NULLCP, "substrings %s substrings: %d", PEPY_ERR_TOO_MANY_TAGGED,
		p114 -> pe_cardinal);
	return NOTOK;
    }
    p113 = first_member (p114);

 }
#endif

{
    register PE p115;


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

    {
	parm->fi_type = FILTERITEM_SUBSTRINGS;
	subs_next = &(parm->fi_un.fi_un_substrings);
	subs_next->fi_sub_initial = NULLAV;
	subs_next->fi_sub_any = NULLAV;
	subs_next->fi_sub_final = NULLAV;
	avs_initial = &(subs_next->fi_sub_initial);
	avs_any = &(subs_next->fi_sub_any);
	avs_final = &(subs_next->fi_sub_final);

    }
    if ((p115 = prim2seq (p113)) == NULLPE) {
	advise (NULLCP, "substrings %s%s", PEPY_ERR_BAD_SEQ,
		pe_error (p113 -> pe_errno));
	return NOTOK;
    }
    p113 = p115;

    {
	register PE p116;

	if ((p116 = first_member (p113)) != NULLPE) {
	    p115 = p116;

	    {	/* type */