DataMuseum.dk

top - metrics - download

    Length: 15210 (0x3b6a)
    Types: TextFile
    Names: »mfree.c«

└─⟦2d1937cfd⟧ Bits:30007241 EUUGD22: P.P 5.0
    └─⟦e83f91978⟧ »EurOpenD22/isode/osimis-2.0.tar.Z« 
        └─⟦d846658bd⟧ 
            └─⟦this⟧ »osimis/msap/mfree.c« 

TextFile

/*
 * Copyright (c) 1988 University College London
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that the above copyright notice and this parasraph are
 * duplicated in all such forms and that any documentation,
 * advertising materials, and other materials related to such
 * distribution and use acknowledge that the software was developed
 * by the Department of Computer Science, University College London.
 * The name of the University may not be used to
 * endorse or promote products derived from this software without
 * specific prior written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

/* Management data structures freeing routines */

/*
 * By George Pavlou, April 1990
 */

#include <stdio.h>
#include "isode/rosap.h"
#include "msap.h"

/* LINTLIBRARY */

mfilter_free (filter)
CMISfilter * filter;
{
    register CMISfilter * this;

    for (; filter != NULLFILTER;) {
	filter = (this = filter) -> flt_next;
	if (this -> flt_type == Filter_Item) {
	    register FilterItem * item = this -> flt_item;
	    switch (item -> fi_type) {
	    case FI_Equality:
	    case FI_GreaterOrEqual:
	    case FI_LessOrEqual:
	    case FI_SubsetOf:
	    case FI_SupersetOf:
	    case FI_NonNullSetIntersect:
		if (item -> fi_attr.mp_id.mid_type == MID_GLOBAL &&
			item -> fi_attr.mp_id.mid_global != NULLOID)
		    oid_free(item -> fi_attr.mp_id.mid_global);
		if (item -> fi_attr.mp_val != NULLPE)
		    pe_free(item -> fi_attr.mp_val);
		break;

	    case FI_Present:
		if (item -> fi_attr.mp_id.mid_type == MID_GLOBAL &&
			item -> fi_attr.mp_id.mid_global != NULLOID)
		    oid_free(item -> fi_attr.mp_id.mid_global);
		break;

	    case FI_Substrings:
	    {   register FilterSubstrings * substring = item -> fi_substrings,
					  * thisone;
		for (; substring;) {
		    substring = (thisone = substring) -> fi_sub_next;
		    if (thisone -> fi_sub_attrid.mid_type == MID_GLOBAL &&
				thisone -> fi_sub_attrid.mid_global != NULLOID)
			oid_free(thisone -> fi_sub_attrid.mid_global);
		    if (thisone -> fi_sub_string != NULLCP)
			free(thisone -> fi_sub_string);
		    free ((char *) thisone);
		}
	    }
		break;
	    }
	}
	else
	    mfilter_free(this -> flt_filter);

	free ((char *) this);
    }
}

mcfree (mc)
struct MSAPconnect * mc;
{
    if (mc->mc_context)
	oid_free(mc->mc_context),
	mc->mc_context = NULLOID;

    if (mc->mc_resptitle.aei_ap_title)
	pe_free( mc->mc_resptitle.aei_ap_title),
	mc->mc_resptitle.aei_ap_title = NULLPE;

    if (mc->mc_resptitle.aei_ae_qualifier)
	pe_free( mc->mc_resptitle.aei_ae_qualifier),
	mc->mc_resptitle.aei_ae_qualifier = NULLPE;

    if (mc->mc_info.mai_access)
	external_free(mc->mc_info.mai_access),
	mc->mc_info.mai_access = NULL;

    if (mc->mc_info.mai_info)
	external_free(mc->mc_info.mai_info),
	mc->mc_info.mai_info = NULL;
}

msfree (ms)
struct MSAPstart * ms;
{
    if (ms->ms_calling.aei_ap_title)
	pe_free( ms->ms_calling.aei_ap_title),
	ms->ms_calling.aei_ap_title = NULLPE;

    if (ms->ms_calling.aei_ae_qualifier)
	pe_free( ms->ms_calling.aei_ae_qualifier),
	ms->ms_calling.aei_ae_qualifier = NULLPE;

    if (ms->ms_called.aei_ap_title)
	pe_free( ms->ms_called.aei_ap_title),
	ms->ms_called.aei_ap_title = NULLPE;

    if (ms->ms_called.aei_ae_qualifier)
	pe_free( ms->ms_called.aei_ae_qualifier),
	ms->ms_called.aei_ae_qualifier = NULLPE;

    PSFREE(&ms->ms_start);

    if (ms->ms_context)
	oid_free(ms->ms_context),
	ms->ms_context = NULLOID;

    if (ms->ms_info.mai_access)
	external_free(ms->ms_info.mai_access),
	ms->ms_info.mai_access = NULL;

    if (ms->ms_info.mai_info)
	external_free(ms->ms_info.mai_info),
	ms->ms_info.mai_info = NULL;
}

mafree (ma)
struct MSAPabort * ma;
{
    if (ma->ma_info)
	external_free(ma->ma_info),
	ma->ma_info = NULL;
}

static  mgetarg_free (ga)
struct get_arg * ga;
{
    register MID attr;

    if (ga -> ga_class.mid_type == MID_GLOBAL &&
		ga -> ga_class.mid_global != NULLOID)
	oid_free(ga -> ga_class.mid_global);
    if (ga -> ga_inst.mn_type == MN_DN && ga -> ga_inst.mn_dn != NULLDN)
	dn_free(ga -> ga_inst.mn_dn);
    else
    if (ga -> ga_inst.mn_type == MN_NONSPEC &&
		ga -> ga_inst.mn_nonspec != NULLCP)
	free(ga -> ga_inst.mn_nonspec);
    if (ga -> ga_access)
	external_free(ga -> ga_access);
    if (ga -> ga_filter != NULLFILTER)
	mfilter_free(ga -> ga_filter);
    for (attr = ga -> ga_attrs; ga -> ga_nattrs--; attr++)
	if (attr -> mid_type == MID_GLOBAL && attr -> mid_global != NULLOID)
	    oid_free(attr -> mid_global);
}

static  mgetres_free (gr)
struct get_res * gr;
{
    register CMISparam * attr;

    if (gr -> gr_class.mid_type == MID_GLOBAL &&
		gr -> gr_class.mid_global != NULLOID)
	oid_free(gr -> gr_class.mid_global);
    if (gr -> gr_inst.mn_type == MN_DN && gr -> gr_inst.mn_dn != NULLDN)
	dn_free(gr -> gr_inst.mn_dn);
    else
    if (gr -> gr_inst.mn_type == MN_NONSPEC &&
		gr -> gr_inst.mn_nonspec != NULLCP)
	free(gr -> gr_inst.mn_nonspec);
    if (gr -> gr_time != NULLCP)
	free(gr -> gr_time);
    for (attr = gr -> gr_attrs; gr -> gr_nattrs--; attr++) {
	if (attr -> mp_id.mid_type == MID_GLOBAL &&
			attr -> mp_id.mid_global != NULLOID)
	    oid_free(attr -> mp_id.mid_global);
	if (attr -> mp_val != NULLPE)
	    pe_free(attr -> mp_val);
    }
}

static  msetarg_free (sa)
struct set_arg * sa;
{
    register CMISparam * attr;

    if (sa -> sa_class.mid_type == MID_GLOBAL &&
		sa -> sa_class.mid_global != NULLOID)
	oid_free(sa -> sa_class.mid_global);
    if (sa -> sa_inst.mn_type == MN_DN && sa -> sa_inst.mn_dn != NULLDN)
	dn_free(sa -> sa_inst.mn_dn);
    else
    if (sa -> sa_inst.mn_type == MN_NONSPEC &&
		sa -> sa_inst.mn_nonspec != NULLCP)
	free(sa -> sa_inst.mn_nonspec);
    if (sa -> sa_access)
	external_free(sa -> sa_access);
    if (sa -> sa_filter != NULLFILTER)
	mfilter_free(sa -> sa_filter);
    for (attr = sa -> sa_attrs; sa -> sa_nattrs--; attr++) {
	if (attr -> mp_id.mid_type == MID_GLOBAL &&
			attr -> mp_id.mid_global != NULLOID)
	    oid_free(attr -> mp_id.mid_global);
	if (attr -> mp_val != NULLPE)
	    pe_free(attr -> mp_val);
    }
}

static  msetres_free (sr)
struct set_res * sr;
{
    register CMISparam * attr;

    if (sr -> sr_class.mid_type == MID_GLOBAL &&
		sr -> sr_class.mid_global != NULLOID)
	oid_free(sr -> sr_class.mid_global);
    if (sr -> sr_inst.mn_type == MN_DN && sr -> sr_inst.mn_dn != NULLDN)
	dn_free(sr -> sr_inst.mn_dn);
    else
    if (sr -> sr_inst.mn_type == MN_NONSPEC &&
		sr -> sr_inst.mn_nonspec != NULLCP)
	free(sr -> sr_inst.mn_nonspec);
    if (sr -> sr_time != NULLCP)
	free(sr -> sr_time);
    for (attr = sr -> sr_attrs; sr -> sr_nattrs--; attr++) {
	if (attr -> mp_id.mid_type == MID_GLOBAL &&
			attr -> mp_id.mid_global != NULLOID)
	    oid_free(attr -> mp_id.mid_global);
	if (attr -> mp_val != NULLPE)
	    pe_free(attr -> mp_val);
    }
}

static  meventreparg_free (ea)
struct event_rep_arg * ea;
{
    if (ea -> ea_class.mid_type == MID_GLOBAL &&
		ea -> ea_class.mid_global != NULLOID)
	oid_free(ea -> ea_class.mid_global);
    if (ea -> ea_inst.mn_type == MN_DN && ea -> ea_inst.mn_dn != NULLDN)
	dn_free(ea -> ea_inst.mn_dn);
    else
    if (ea -> ea_inst.mn_type == MN_NONSPEC &&
		ea -> ea_inst.mn_nonspec != NULLCP)
	free(ea -> ea_inst.mn_nonspec);
    if (ea -> ea_time != NULLCP)
	free(ea -> ea_time);
    if (ea -> ea_type.mid_type == MID_GLOBAL &&
		ea -> ea_type.mid_global != NULLOID)
	oid_free(ea -> ea_type.mid_global);
    if (ea -> ea_info != NULLPE)
	pe_free(ea -> ea_info);
}

static  meventrepres_free (er)
struct event_rep_res * er;
{
    if (er -> er_class.mid_type == MID_GLOBAL &&
		er -> er_class.mid_global != NULLOID)
	oid_free(er -> er_class.mid_global);
    if (er -> er_inst.mn_type == MN_DN && er -> er_inst.mn_dn != NULLDN)
	dn_free(er -> er_inst.mn_dn);
    else
    if (er -> er_inst.mn_type == MN_NONSPEC &&
		er -> er_inst.mn_nonspec != NULLCP)
	free(er -> er_inst.mn_nonspec);
    if (er -> er_time != NULLCP)
	free(er -> er_time);
    if (er -> er_reply.mp_id.mid_type == MID_GLOBAL &&
			er -> er_reply.mp_id.mid_global != NULLOID)
	    oid_free(er -> er_reply.mp_id.mid_global);
    if (er -> er_reply.mp_val != NULLPE)
	    pe_free(er -> er_reply.mp_val);
}

static  mactionarg_free (aa)
struct action_arg * aa;
{
    if (aa -> aa_class.mid_type == MID_GLOBAL &&
		aa -> aa_class.mid_global != NULLOID)
	oid_free(aa -> aa_class.mid_global);
    if (aa -> aa_inst.mn_type == MN_DN && aa -> aa_inst.mn_dn != NULLDN)
	dn_free(aa -> aa_inst.mn_dn);
    else
    if (aa -> aa_inst.mn_type == MN_NONSPEC &&
		aa -> aa_inst.mn_nonspec != NULLCP)
	free(aa -> aa_inst.mn_nonspec);
    if (aa -> aa_access)
	external_free(aa -> aa_access);
    if (aa -> aa_filter != NULLFILTER)
	mfilter_free(aa -> aa_filter);
    if (aa -> aa_info.mp_id.mid_type == MID_GLOBAL &&
			aa -> aa_info.mp_id.mid_global != NULLOID)
	    oid_free(aa -> aa_info.mp_id.mid_global);
    if (aa -> aa_info.mp_val != NULLPE)
	pe_free(aa -> aa_info.mp_val);
}

static  mactionres_free (ar)
struct action_res * ar;
{
    if (ar -> ar_class.mid_type == MID_GLOBAL &&
		ar -> ar_class.mid_global != NULLOID)
	oid_free(ar -> ar_class.mid_global);
    if (ar -> ar_inst.mn_type == MN_DN && ar -> ar_inst.mn_dn != NULLDN)
	dn_free(ar -> ar_inst.mn_dn);
    else
    if (ar -> ar_inst.mn_type == MN_NONSPEC &&
		ar -> ar_inst.mn_nonspec != NULLCP)
	free(ar -> ar_inst.mn_nonspec);
    if (ar -> ar_time != NULLCP)
	free(ar -> ar_time);
    if (ar -> ar_reply.mp_id.mid_type == MID_GLOBAL &&
			ar -> ar_reply.mp_id.mid_global != NULLOID)
	    oid_free(ar -> ar_reply.mp_id.mid_global);
    if (ar -> ar_reply.mp_val != NULLPE)
	    pe_free(ar -> ar_reply.mp_val);
}

static  mcreatearg_free (ca)
struct create_arg * ca;
{
    register CMISparam * attr;

    if (ca -> ca_class.mid_type == MID_GLOBAL &&
		ca -> ca_class.mid_global != NULLOID)
	oid_free(ca -> ca_class.mid_global);
    if (ca -> ca_inst.mn_type == MN_DN && ca -> ca_inst.mn_dn != NULLDN)
	dn_free(ca -> ca_inst.mn_dn);
    else
    if (ca -> ca_inst.mn_type == MN_NONSPEC &&
		ca -> ca_inst.mn_nonspec != NULLCP)
	free(ca -> ca_inst.mn_nonspec);
    if (ca -> ca_refinst.mn_type == MN_DN && ca -> ca_refinst.mn_dn != NULLDN)
	dn_free(ca -> ca_refinst.mn_dn);
    else
    if (ca -> ca_refinst.mn_type == MN_NONSPEC &&
		ca -> ca_refinst.mn_nonspec != NULLCP)
	free(ca -> ca_refinst.mn_nonspec);
    if (ca -> ca_access)
	external_free(ca -> ca_access);
    for (attr = ca -> ca_attrs; ca -> ca_nattrs--; attr++) {
	if (attr -> mp_id.mid_type == MID_GLOBAL &&
			attr -> mp_id.mid_global != NULLOID)
	    oid_free(attr -> mp_id.mid_global);
	if (attr -> mp_val != NULLPE)
	    pe_free(attr -> mp_val);
    }
}

static  mcreateres_free (cr)
struct create_res * cr;
{
    register CMISparam * attr;

    if (cr -> cr_class.mid_type == MID_GLOBAL &&
		cr -> cr_class.mid_global != NULLOID)
	oid_free(cr -> cr_class.mid_global);
    if (cr -> cr_inst.mn_type == MN_DN && cr -> cr_inst.mn_dn != NULLDN)
	dn_free(cr -> cr_inst.mn_dn);
    else
    if (cr -> cr_inst.mn_type == MN_NONSPEC &&
		cr -> cr_inst.mn_nonspec != NULLCP)
	free(cr -> cr_inst.mn_nonspec);
    if (cr -> cr_time != NULLCP)
	free(cr -> cr_time);
    for (attr = cr -> cr_attrs; cr -> cr_nattrs--; attr++) {
	if (attr -> mp_id.mid_type == MID_GLOBAL &&
			attr -> mp_id.mid_global != NULLOID)
	    oid_free(attr -> mp_id.mid_global);
	if (attr -> mp_val != NULLPE)
	    pe_free(attr -> mp_val);
    }
}

static  mdeletearg_free (da)
struct delete_arg * da;
{
    if (da -> da_class.mid_type == MID_GLOBAL &&
		da -> da_class.mid_global != NULLOID)
	oid_free(da -> da_class.mid_global);
    if (da -> da_inst.mn_type == MN_DN && da -> da_inst.mn_dn != NULLDN)
	dn_free(da -> da_inst.mn_dn);
    else
    if (da -> da_inst.mn_type == MN_NONSPEC &&
		da -> da_inst.mn_nonspec != NULLCP)
	free(da -> da_inst.mn_nonspec);
    if (da -> da_access)
	external_free(da -> da_access);
    if (da -> da_filter != NULLFILTER)
	mfilter_free(da -> da_filter);
}

static  mdeleteres_free (dr)
struct delete_res * dr;
{
    if (dr -> dr_class.mid_type == MID_GLOBAL &&
		dr -> dr_class.mid_global != NULLOID)
	oid_free(dr -> dr_class.mid_global);
    if (dr -> dr_inst.mn_type == MN_DN && dr -> dr_inst.mn_dn != NULLDN)
	dn_free(dr -> dr_inst.mn_dn);
    else
    if (dr -> dr_inst.mn_type == MN_NONSPEC &&
		dr -> dr_inst.mn_nonspec != NULLCP)
	free(dr -> dr_inst.mn_nonspec);
    if (dr -> dr_time != NULLCP)
	free(dr -> dr_time);
}

static  merror_free (me)
struct CMISerrparam * me;
{
    if (me -> me_class.mid_type == MID_GLOBAL &&
		me -> me_class.mid_global != NULLOID)
	oid_free(me -> me_class.mid_global);
    if (me -> me_inst.mn_type == MN_DN && me -> me_inst.mn_dn != NULLDN)
	dn_free(me -> me_inst.mn_dn);
    if (me -> me_time != NULLCP)
	free(me -> me_time);
    if (me -> me_filter != NULLFILTER)
	mfilter_free(me -> me_filter);
    if (me -> me_id.mid_type == MID_GLOBAL &&
		me -> me_id.mid_global != NULLOID)
	oid_free(me -> me_id.mid_global);
    if (me -> me_val != NULLPE)
	pe_free(me -> me_val);
}

static  mlinkedreplyarg_free (lr)
struct linked_reply_arg * lr;
{
    switch (lr -> lr_type) {
    case LR_GET_RES:
    case LR_GET_LISTERR:
	mgetres_free(&lr -> lr_getr);
	break;

    case LR_SET_RES:
    case LR_SET_LISTERR:
	msetres_free(&lr -> lr_setr);
	break;

    case LR_ACTION_RES:
	mactionres_free(&lr -> lr_actionr);
	break;

    case LR_DELETE_RES:
	mdeleteres_free(&lr -> lr_deleter);
	break;

    case LR_ACTION_ERR:
    case LR_DELETE_ERR:
    case LR_PROC_FAIL:
	merror_free(&lr -> lr_error);
	break;

    case LR_UNKNOWN:
	break;
    }
}

int  mifree (mi)
struct MSAPindication * mi;
{
    switch (mi -> mi_type) {
    case MI_EVENT_REP:
    case MI_EVENT_REPC:
	meventreparg_free(&mi -> mi_eventrepv.args);
	break;

    case MI_EVENT_REP_RES:
	meventrepres_free(&mi -> mi_eventrepr.result);
	break;

    case MI_LINKED_REPLY:
	mlinkedreplyarg_free(&mi -> mi_linkedreplyv.args);
	break;

    case MI_GET:
	mgetarg_free(&mi -> mi_getv.args);
	break;

    case MI_GET_RES:
	mgetres_free(&mi -> mi_getr.result);
	break;

    case MI_SET:
    case MI_SETC:
	msetarg_free(&mi -> mi_setv.args);
	break;

    case MI_SET_RES:
	msetres_free(&mi -> mi_setr.result);
	break;

    case MI_ACTION:
    case MI_ACTIONC:
	mactionarg_free(&mi -> mi_actionv.args);
	break;

    case MI_ACTION_RES:
	mactionres_free(&mi -> mi_actionr.result);
	break;

    case MI_CREATE:
	mcreatearg_free(&mi -> mi_createv.args);
	break;

    case MI_CREATE_RES:
	mcreateres_free(&mi -> mi_creater.result);
	break;

    case MI_DELETE:
	mdeletearg_free(&mi -> mi_deletev.args);
	break;

    case MI_DELETE_RES:
	mdeleteres_free(&mi -> mi_deleter.result);
	break;

    case MI_ERROR:
	if (mi -> mi_errtype == m_getListError)
	    mgetres_free(&mi -> mi_getr.result);
	else
	if (mi -> mi_errtype == m_setListError)
	    msetres_free(&mi -> mi_setr.result);
	else
	    merror_free(&mi -> mi_error.info);
	break;

    case MI_TERM:
    case MI_ABORT:
    case MI_PREJECT:
    case MI_UNKNOWN:
	break;
    }
}