ds_types.c

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

/* ds_types.c - Bind argument and operation argument type routines */

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

/* 
 * $Header: /xtel/isode/isode/dsap/net/RCS/ds_types.c,v 9.0 1992/06/16 12:14:05 isode Rel $
 *
 *
 * $Log: ds_types.c,v $
 * Revision 9.0  1992/06/16  12:14:05  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/bind.h"
#include "quipu/common.h"
#include "quipu/dsargument.h"

extern LLog * log_dsap;

bind_arg_free (arg)
struct ds_bind_arg          *arg;
{
	if (arg->dba_time1 != NULLCP)
		free (arg->dba_time1);

	if (arg->dba_time2 != NULLCP)
		free (arg->dba_time2);

	dn_free (arg->dba_dn);
	arg->dba_dn = NULLDN;

	/* free signature */
	/* free certificate_list */
}

op_arg_free (arg)
struct ds_op_arg * arg;
{
	DLOG(log_dsap, LLOG_TRACE, ("op_arg_free()"));

	if (arg->dca_dsarg.arg_type == -1 )
		/* Already freed - argument part anyway */
		return;

	DLOG(log_dsap, LLOG_TRACE, ("op_arg_free() - for real"));


	switch (arg->dca_dsarg.arg_type)
	{
	    case OP_ABANDON:

		ds_arg_free (&(arg->dca_dsarg));
		break;

	    case OP_GETEDB:
	    case OP_READ:
	    case OP_COMPARE:
	    case OP_LIST:
	    case OP_SEARCH:
	    case OP_ADDENTRY:
	    case OP_REMOVEENTRY:
	    case OP_MODIFYENTRY:
	    case OP_MODIFYRDN:

		ch_arg_free (&(arg->dca_charg));
		ds_arg_free (&(arg->dca_dsarg));
		break;

	    default:
		break;
	}
}

ch_arg_free (arg)
struct chain_arg * arg;
{
	DLOG(log_dsap, LLOG_TRACE, ("ch_arg_free(%x)",arg));

	dn_free (arg->cha_originator);
	arg->cha_originator = NULLDN;

	dn_free (arg->cha_target);
	arg->cha_target = NULLDN;

	if (arg->cha_domaininfo != NULLPE) {
		pe_free (arg->cha_domaininfo);
		arg->cha_domaininfo = NULLPE;
	    }

	if(arg->cha_trace != NULLTRACEINFO) {
		trace_info_free (arg->cha_trace);
		arg->cha_trace = NULLTRACEINFO;
	    }

	if (arg->cha_timelimit != NULLCP) {
		free (arg->cha_timelimit);
		arg->cha_timelimit = NULLCP;
	}
}

ds_arg_free (arg)
struct DSArgument * arg;
{
	DLOG(log_dsap, LLOG_TRACE, ("ds_arg_free()"));

	if (arg->arg_type == -1 )
		/* Already freed */
		return;

	DLOG(log_dsap, LLOG_TRACE, ("ds_arg_free() for real"));

	/* free argument structure */
	switch (arg->arg_type) {
	case OP_READ:
		read_arg_free (&(arg->arg_rd));
		break;
	case OP_COMPARE:
		compare_arg_free (&(arg->arg_cm));
		break;
	case OP_ABANDON:
		break;
	case OP_LIST:
		list_arg_free (&(arg->arg_ls));
		break;
	case OP_SEARCH:
		search_arg_free (&(arg->arg_sr));
		break;
	case OP_ADDENTRY:
		addentry_arg_free (&(arg->arg_ad));
		break;
	case OP_REMOVEENTRY:		
		removeentry_arg_free (&(arg->arg_rm));
		break;
	case OP_MODIFYENTRY:
		modifyentry_arg_free (&(arg->arg_me));
		break;
	case OP_MODIFYRDN:
		modifyrdn_arg_free (&(arg->arg_mr));
		break;
	case OP_GETEDB:
		getedb_arg_free (&(arg->arg_ge));
		break;
	default:
		break;
	}

	/* indicate as freed */
	arg->arg_type = -1;
}

read_arg_free (arg)
struct ds_read_arg	* arg;
{
	ca_free (&arg->rda_common);
	dn_free (arg->rda_object);
	as_free (arg->rda_eis.eis_select);
}

compare_arg_free (arg)
struct ds_compare_arg	* arg;
{
	ca_free (&arg->cma_common);
	dn_free (arg->cma_object);
	AttrT_free (arg->cma_purported.ava_type);
	AttrV_free (arg->cma_purported.ava_value);
}

list_arg_free (arg)
struct ds_list_arg	* arg;
{
	ca_free (&arg->lsa_common);
	dn_free (arg->lsa_object);
}

search_arg_free (arg)
struct ds_search_arg	* arg;
{
	ca_free (&arg->sra_common);
	dn_free (arg->sra_baseobject);
	as_free (arg->sra_eis.eis_select);
	filter_free (arg->sra_filter);
}

addentry_arg_free (arg)
struct ds_addentry_arg	* arg;
{
	ca_free (&arg->ada_common);
	dn_free (arg->ada_object);
	as_free (arg->ada_entry);
}

removeentry_arg_free (arg)
struct ds_removeentry_arg	* arg;
{
	ca_free (&arg->rma_common);
	dn_free (arg->rma_object);
}

modifyentry_arg_free (arg)
struct ds_modifyentry_arg	* arg;
{
	ca_free (&arg->mea_common);
	dn_free (arg->mea_object);
	ems_free (arg->mea_changes);
}

modifyrdn_arg_free (arg)
struct ds_modifyrdn_arg	* arg;
{
	ca_free (&arg->mra_common);
	dn_free (arg->mra_object);
	rdn_free (arg->mra_newrdn);
}

getedb_arg_free (arg)
struct getedb_arg	* arg;
{
	dn_free (arg->ga_entry);
	free ((char *)arg->ga_version);
}

op_res_free (res)
struct ds_op_res * res;
{
	DLOG(log_dsap, LLOG_TRACE, ("op_res_free()"));

	if (res->dcr_dsres.result_type == -1 )
		/* Already freed - result part anyway */
		return;

	DLOG(log_dsap, LLOG_TRACE, ("op_res_free() - for real"));

	switch (res->dcr_dsres.result_type)
	{
	    case OP_ABANDON:
	    case OP_GETEDB:

		ds_res_free (&(res->dcr_dsres));
		break;

	    case OP_READ:
	    case OP_COMPARE:
	    case OP_LIST:
	    case OP_SEARCH:
	    case OP_ADDENTRY:
	    case OP_REMOVEENTRY:
	    case OP_MODIFYENTRY:
	    case OP_MODIFYRDN:

		ch_res_free (&(res->dcr_chres));
		ds_res_free (&(res->dcr_dsres));
		break;

	    default:
		break;
	}

}

ch_res_free (res)
struct chain_res	* res;
{
	DLOG(log_dsap, LLOG_TRACE, ("ch_res_free()"));

	/* free chain bits */
	if (res->chr_domaininfo != NULLPE)
		pe_free (res->chr_domaininfo);

	cross_refs_free (res->chr_crossrefs);
}

ds_res_free (res)
struct DSResult	* res;
{
	DLOG(log_dsap, LLOG_TRACE, ("ds_res_free()"));

	if (res->result_type == -1 )
		/* Already freed */
		return;

	DLOG(log_dsap, LLOG_TRACE, ("ds_res_free() - for real"));

	switch (res->result_type) {
	case OP_READ:
		dn_free (res->res_rd.rdr_common.cr_requestor);
		entryinfo_comp_free (&res->res_rd.rdr_entry,0);
		break;
	case OP_COMPARE:
		dn_free (res->res_cm.cmr_common.cr_requestor);
		dn_free (res->res_cm.cmr_object);
		break;
	case OP_LIST:
		dn_free (res->res_ls.lsr_common.cr_requestor);
		dn_free (res->res_ls.lsr_object);
		subords_free (res->res_ls.lsr_subordinates);
		crefs_free (res->res_ls.lsr_cr);
		break;
	case OP_SEARCH:
		search_result_free(&(res->res_sr));
		break;
	case OP_GETEDB:
		if (res->res_ge.gr_version)
			free (res->res_ge.gr_version);
		res->res_ge.gr_version = NULLCP;
		if (res->res_ge.gr_encoded)
			pe_free (res->res_ge.gr_pe);
		break;	
	default:
		break;
	}

	res->result_type = -1;
}

trace_info_free (ti)
struct trace_info * ti;
{
	DLOG(log_dsap, LLOG_TRACE, ("trace_info_free()"));

	if (ti == NULLTRACEINFO)
		return;
	dn_free (ti->ti_target);
	dn_free (ti->ti_dsa);
	trace_info_free (ti->ti_next);
	free( (char *) ti);

}

ca_free (ca)
CommonArgs * ca;
{
	DLOG(log_dsap, LLOG_TRACE, ("ca_free()"));

	dn_free (ca->ca_requestor);
	extension_free (ca->ca_extensions);
}

extension_free (ext)
struct extension * ext;
{
	DLOG(log_dsap, LLOG_TRACE, ("extension_free()"));

	for (; ext != NULLEXT; ext=ext->ext_next) {
		if (ext->ext_item != NULLPE)
			pe_free (ext->ext_item);
		free ((char *) ext);
	}
}

cross_refs_free (xref)
struct cross_ref * xref;
{
	DLOG(log_dsap, LLOG_TRACE, ("cross_refs_free()"));

	if (xref == NULLXREF)
		return;
	dn_free (xref->xref_dn);
	aps_free (xref->xref_ap);
	cross_refs_free (xref->xref_next);
	free ((char *)xref);
}

/* Copy routines */

int	  ds_arg_dup (src, tgt)
struct DSArgument * src;
struct DSArgument * tgt;
{
	DLOG(log_dsap, LLOG_TRACE, ("ds_arg_dup()"));

	if (src->arg_type == -1 )
	{
		/* Has been freed */
		LLOG (log_dsap, LLOG_DEBUG, ("ds_arg_dup(): src already freed"));
		return (NOTOK);
	}

	switch (tgt->arg_type = src->arg_type) {
	case OP_READ:
		return (read_arg_dup (&(src->arg_rd), &(tgt->arg_rd)));
	case OP_COMPARE:
		return (compare_arg_dup (&(src->arg_cm), &(tgt->arg_cm)));
	case OP_ABANDON:
		return (abandon_arg_dup (&(src->arg_ab), &(tgt->arg_ab)));
	case OP_LIST:
		return (list_arg_dup (&(src->arg_ls), &(tgt->arg_ls)));
	case OP_SEARCH:
		return (search_arg_dup (&(src->arg_sr), &(tgt->arg_sr)));
	case OP_ADDENTRY:
		return (addentry_arg_dup (&(src->arg_ad), &(tgt->arg_ad)));
	case OP_REMOVEENTRY:		
		return (removeentry_arg_dup (&(src->arg_rm), &(tgt->arg_rm)));
	case OP_MODIFYENTRY:
		return (modifyentry_arg_dup (&(src->arg_me), &(tgt->arg_me)));
	case OP_MODIFYRDN:
		return (modifyrdn_arg_dup (&(src->arg_mr), &(tgt->arg_mr)));
	case OP_GETEDB:
		return (getedb_arg_dup (&(src->arg_ge), &(tgt->arg_ge)));
	default:
		LLOG(log_dsap, LLOG_DEBUG, ("ds_arg_dup(): unknown arg type %d", src->arg_type));
		return (NOTOK);
	}
}

int	  read_arg_dup (src, tgt)
struct ds_read_arg	* src;
struct ds_read_arg	* tgt;
{
	if (ca_dup (&(src->rda_common), &(tgt->rda_common)) != OK)
	    return (NOTOK);

	if (src->rda_object == NULLDN)
		tgt->rda_object = NULLDN;
	else if ((tgt->rda_object = dn_cpy (src->rda_object)) == NULLDN)
		return (NOTOK);

	if (eis_dup (&(src->rda_eis), &(tgt->rda_eis)) != OK)
	    return (NOTOK);

	return (OK);
}

int	compare_arg_dup (src, tgt)
struct ds_compare_arg	* src;
struct ds_compare_arg	* tgt;
{
	if (ca_dup (&(src->cma_common), &(tgt->cma_common)) != OK)
	    return (NOTOK);

	if (src->cma_object == NULLDN)
		tgt->cma_object = NULLDN;
	else if ((tgt->cma_object = dn_cpy (src->cma_object)) == NULLDN)
		return (NOTOK);

	if (ava_dup (&(src->cma_purported), &(tgt->cma_purported)) != OK)
	    return (NOTOK);

	return (OK);
}