asn_ext.c

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

 *		[1] SET OF
 *                	OBJECT IDENTIFIER [[O oid_tmp]]
 *                	%{
 *				if(is_first != 0)
 *				{
 *                			(*parm) = tree_struct_alloc();
 *                        		if (((*parm)->tree_object = oid2oc(oid_tmp)) == NULLOBJECTCLASS)
 *						(*parm)->tree_object = oc_add (oid_tmp);
 *					is_first = 0;
 *				}
 *				else
 *				{
 *					LLOG(log_dsap, LLOG_EXCEPTIONS, ("Multiple mandatory object classes"));
 *				}
 *                	%} ,
 *	optionalObjectClasses
 *		[2] SET OF
 *                	OBJECT IDENTIFIER
 *		    OPTIONAL ,
 *	permittedRDNs
 *		[3] SET OF
 *			SET OF
 *				AttributeType [[p & at_tmp]]
 *				%{
 *				%}
 *	}
 *        %{
 *                DLOG(log_dsap, LLOG_PDUS, ("Done decode TreeStructureSyntax"));
 *        %}
 *
 *
 */


treestruct_decode (parm,pe)
struct tree_struct ** parm;
PE pe;
{

AttributeType	  at_tmp;
OID     oid_tmp;
int	is_first;
objectclass * oc_add();
char explicit = 0;

    int p34_count = 0;
    register PE p34;

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

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

    {

		is_first = 1;
        
    }
    if ((p34 = prim2set (pe)) == NULLPE) {
        advise (NULLCP, "TreeStructureSyntax %s%s", PEPY_ERR_BAD_SET,
                pe_error (pe -> pe_errno));
        return NOTOK;
    }
    pe = p34;

    if (p34 = set_find (pe, PE_CLASS_CONT, 1)) {
        register PE p35 = p34;

        {	/* mandatoryObjectClasses TAG PULLUP */
            register PE p36;

            if ((p36 = prim2set (p35)) == NULLPE) {
                advise (NULLCP, "mandatoryObjectClasses %smandatoryObjectClasses: %s", PEPY_ERR_BAD,
                        pe_error (p35 -> pe_errno));
                return NOTOK;
            }
            if (p36 -> pe_cardinal != 1) {
                advise (NULLCP, "mandatoryObjectClasses %s mandatoryObjectClasses: %d", PEPY_ERR_TOO_MANY_TAGGED,
                        p36 -> pe_cardinal);
                return NOTOK;
            }
            p35 = first_member (p36);
        }
        {
            register PE p37;

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

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

            if ((p37 = prim2set (p35)) == NULLPE) {
                advise (NULLCP, "mandatoryObjectClasses %s%s", PEPY_ERR_BAD_SET,
                        pe_error (p35 -> pe_errno));
                return NOTOK;
            }
            p35 = p37;

            for (p37 = first_member (p35); p37; p37 = next_member (p35, p37)) {
                register OID p38;

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

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

                if ((p38 = prim2oid (p37)) == NULLOID) {
                    advise (NULLCP, "member %s%s", PEPY_ERR_BAD_OID,
                            pe_error (p37 -> pe_errno));
                    return NOTOK;
                }

/* Spurious copy noticed by Jim Reed
                oid_tmp = oid_cpy (p38);
*/
		oid_tmp = p38;
                {

				if(is_first != 0)
				{
                			(*parm) = tree_struct_alloc();
                        		if (((*parm)->tree_object = oid2oc(oid_tmp)) == NULLOBJECTCLASS) 
						(*parm)->tree_object = oc_add (oid_tmp);
					is_first = 0;
				}
				else
				{
					LLOG(log_dsap, LLOG_EXCEPTIONS, ("Multiple mandatory object classes"));
				}
                	
                }
            }
        }
        p34_count ++;
    }
    else {
        advise (NULLCP, "mandatoryObjectClasses %s mandatoryObjectClasses member", PEPY_ERR_MISSING);
        return NOTOK;
    }

    if (p34 = set_find (pe, PE_CLASS_CONT, 2)) {
        register PE p39 = p34;

        {	/* optionalObjectClasses TAG PULLUP */
            register PE p40;

            if ((p40 = prim2set (p39)) == NULLPE) {
                advise (NULLCP, "optionalObjectClasses %soptionalObjectClasses: %s", PEPY_ERR_BAD,
                        pe_error (p39 -> pe_errno));
                return NOTOK;
            }
            if (p40 -> pe_cardinal != 1) {
                advise (NULLCP, "optionalObjectClasses %s optionalObjectClasses: %d", PEPY_ERR_TOO_MANY_TAGGED,
                        p40 -> pe_cardinal);
                return NOTOK;
            }
            p39 = first_member (p40);
        }
        {
            register PE p41;

#ifdef DEBUG
            (void) testdebug (p39, "optionalObjectClasses");
#endif

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

            if ((p41 = prim2set (p39)) == NULLPE) {
                advise (NULLCP, "optionalObjectClasses %s%s", PEPY_ERR_BAD_SET,
                        pe_error (p39 -> pe_errno));
                return NOTOK;
            }
            p39 = p41;

            for (p41 = first_member (p39); p41; p41 = next_member (p39, p41)) {
#ifdef DEBUG
                (void) testdebug (p41, "member");
#endif

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

                if (prim2oid (p41) == NULLOID) {
                    advise (NULLCP, "member %s%s", PEPY_ERR_BAD_OID,
                            pe_error (p41 -> pe_errno));
                    return NOTOK;
                }
            }
        }
        p34_count ++;
    }
    if (p34 = set_find (pe, PE_CLASS_CONT, 3)) {
        register PE p42 = p34;

        {	/* permittedRDNs TAG PULLUP */
            register PE p43;

            if ((p43 = prim2set (p42)) == NULLPE) {
                advise (NULLCP, "permittedRDNs %spermittedRDNs: %s", PEPY_ERR_BAD,
                        pe_error (p42 -> pe_errno));
                return NOTOK;
            }
            if (p43 -> pe_cardinal != 1) {
                advise (NULLCP, "permittedRDNs %s permittedRDNs: %d", PEPY_ERR_TOO_MANY_TAGGED,
                        p43 -> pe_cardinal);
                return NOTOK;
            }
            p42 = first_member (p43);
        }
        {
            register PE p44;

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

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

            if ((p44 = prim2set (p42)) == NULLPE) {
                advise (NULLCP, "permittedRDNs %s%s", PEPY_ERR_BAD_SET,
                        pe_error (p42 -> pe_errno));
                return NOTOK;
            }
            p42 = p44;

            for (p44 = first_member (p42); p44; p44 = next_member (p42, p44)) {
                register PE p45;

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

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

                if ((p45 = prim2set (p44)) == NULLPE) {
                    advise (NULLCP, "member %s%s", PEPY_ERR_BAD_SET,
                            pe_error (p44 -> pe_errno));
                    return NOTOK;
                }
                p44 = p45;

                for (p45 = first_member (p44); p45; p45 = next_member (p44, p45)) {
#ifdef DEBUG
                    (void) testdebug (p45, "member");
#endif

                    if (decode_IF_AttributeType (p45, 1, (int *)0, NULLVP, & at_tmp) == NOTOK)
                        return NOTOK;
                }
            }
        }
        p34_count ++;
    }
    else {
        advise (NULLCP, "permittedRDNs %s permittedRDNs member", PEPY_ERR_MISSING);
        return NOTOK;
    }

    if (p34_count != pe -> pe_cardinal)
        advise (NULLCP, "%s", PEPY_ERR_EXTRA_MEMBERS);

	return OK;
}

EDB_encode (parm,pe)
struct getedb_result *parm;
PE *pe;
{
struct entry *ent_tmp;
PE  p31 = NULLPE;
PE  p32_z = NULLPE;
register PE *p32 = &p32_z;

    if (parm->gr_encoded) {
	    *pe = parm->gr_pe;
	    return OK;
    }

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


    for (ent_tmp = (Entry) avl_getfirst(parm->gr_edb); 
	        ent_tmp != NULLENTRY;
 		ent_tmp = (Entry) avl_getnext()) {
	if ((ent_tmp -> e_data != E_DATA_MASTER) && (ent_tmp -> e_data != E_TYPE_SLAVE))
		continue;

        if (encode_Quipu_RelativeEntry (p32, 0, NULL, NULLCP, ent_tmp) == NOTOK)
            return NOTOK;

        (void) seq_addon ((*pe), p31, (*p32));
        p31 = (*p32);
}

    return OK;
}


EDB_decode_force (pparm,pe)
struct getedb_result ** pparm;
PE pe;
{
Avlnode **tree;
struct entry *tmp;
int	entry_cmp();
register PE p46;

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

    if ((p46 = prim2seq (pe)) == NULLPE) {
        advise (NULLCP, "EntryDataBlock %s%s", PEPY_ERR_BAD_SEQ,
                pe_error (pe -> pe_errno));
        return NOTOK;
    }

    pe = p46;

	(*pparm)->gr_encoded = FALSE;
	(*pparm)->gr_edb = NULLAVL;
	tree = &((*pparm)->gr_edb);

    for (p46 = first_member (pe); p46; p46 = next_member (pe, p46)) {
             if (decode_Quipu_RelativeEntry (p46, 1, NULLIP, NULLVP, &tmp)== NOTOK)
                return NOTOK;

	     tmp->e_leaf = TRUE;
	     tmp->e_complete = TRUE;
	     tmp->e_data = E_TYPE_SLAVE;
		if (avl_insert(tree, tmp, entry_cmp,
		    avl_dup_error) == NOTOK)
			LLOG(log_dsap, LLOG_EXCEPTIONS, ("Bad EDB update (contains duplicates)"));
     }


	return OK;
}


EDB_decode (pparm,pe)
struct getedb_result ** pparm;
PE pe;
{

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

    (*pparm)->gr_pe = pe;
    pe -> pe_refcnt++;

    (*pparm)->gr_encoded = TRUE;

    return OK;
}

EDB_free (parm)
struct getedb_result *parm;
{
	/* All done for us at some other time (hopefully) */
	return OK;
}