ds_types.c

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

int	abandon_arg_dup (src, tgt)
struct ds_abandon_arg	* src;
struct ds_abandon_arg	* tgt;
{
	tgt->aba_invokeid = src->aba_invokeid;

	return (OK);
}

int	  list_arg_dup (src, tgt)
struct ds_list_arg	* src;
struct ds_list_arg	* tgt;
{
	if (ca_dup (&(src->lsa_common), &(tgt->lsa_common)) != OK)
	    return (NOTOK);

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

	return OK;
}

int	  search_arg_dup (src, tgt)
struct ds_search_arg	* src;
struct ds_search_arg	* tgt;
{
struct s_filter	* filter_cpy();

	if (ca_dup (&(src->sra_common), &(tgt->sra_common)) != OK)
	    return (NOTOK);

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

	tgt->sra_subset = src->sra_subset;

	if (src->sra_filter == NULLFILTER)
		tgt->sra_filter = NULLFILTER;
	else if ((tgt->sra_filter = filter_cpy (src->sra_filter)) == NULLFILTER)
		return (NOTOK);

	tgt->sra_searchaliases = src->sra_searchaliases;

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

	return (OK);
}

int	  addentry_arg_dup (src, tgt)
struct ds_addentry_arg	* src;
struct ds_addentry_arg	* tgt;
{
	if (ca_dup (&(src->ada_common), &(tgt->ada_common)) != OK)
	    return (NOTOK);

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

	if (src->ada_entry = NULLATTR)
		tgt->ada_entry = NULLATTR;
	else if ((tgt->ada_entry = as_cpy (src->ada_entry)) == NULLATTR)
		return (NOTOK);

	return (OK);
}

int	  removeentry_arg_dup (src, tgt)
struct ds_removeentry_arg	* src;
struct ds_removeentry_arg	* tgt;
{
	if (ca_dup (&(src->rma_common), &(tgt->rma_common)) != OK)
	    return (NOTOK);

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

	return (OK);
}

int	  modifyentry_arg_dup (src, tgt)
struct ds_modifyentry_arg	* src;
struct ds_modifyentry_arg	* tgt;
{
struct entrymod	* ems_cpy();

	if (ca_dup (&(src->mea_common), &(tgt->mea_common)) != OK)
	    return (NOTOK);

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

	if (src->mea_changes == (struct entrymod *) NULL)
		tgt->mea_changes = (struct entrymod *) NULL;
	else if ((tgt->mea_changes = ems_cpy (src->mea_changes)) == (struct entrymod *) NULL)
		return (NOTOK);

	return (OK);
}

int	  modifyrdn_arg_dup (src, tgt)
struct ds_modifyrdn_arg	* src;
struct ds_modifyrdn_arg	* tgt;
{
	if (ca_dup (&(src->mra_common), &(tgt->mra_common)) != OK)
	    return (NOTOK);

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

	if (src->mra_newrdn == NULLRDN)
		tgt->mra_newrdn = NULLRDN;
	else if ((tgt->mra_newrdn = rdn_cpy (src->mra_newrdn)) == NULLRDN)
		return (NOTOK);

	tgt->deleterdn = src->deleterdn;

	return (OK);
}

int	  getedb_arg_dup (src, tgt)
struct getedb_arg	* src;
struct getedb_arg	* tgt;
{
	if (src->ga_entry == NULLDN)
		tgt->ga_entry = NULLDN;
	else if ((tgt->ga_entry = dn_cpy (src->ga_entry)) == NULLDN)
		return (NOTOK);

	tgt->ga_version = strdup (src->ga_version);
	tgt->get_next = NULL_GETARG;
	return (OK);
}

int	  ca_dup (src, tgt)
struct common_args	* src;
struct common_args	* tgt;
{
struct security_parms	* secp_cpy ();
struct signature	* sig_cpy ();
struct extension	* ext_cpy ();

	tgt->ca_servicecontrol = src->ca_servicecontrol; /* struct copy */

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

	tgt->ca_progress = src->ca_progress; /* struct copy */

	tgt->ca_aliased_rdns = src->ca_aliased_rdns;

	if (src->ca_security = (struct security_parms *) NULL)
		tgt->ca_security = (struct security_parms *) NULL;
	else if ((tgt->ca_security = secp_cpy (src->ca_security)) == (struct security_parms *) NULL)
		return (NOTOK);

	if (src->ca_sig == (struct signature *) NULL)
		tgt->ca_sig = (struct signature *) NULL;
	else if ((tgt->ca_sig = sig_cpy (src->ca_sig)) == (struct signature *) NULL)
		return (NOTOK);

	if (src->ca_extensions == (struct extension *) NULL)
		tgt->ca_extensions = (struct extension *) NULL;
	else if ((tgt->ca_extensions = ext_cpy (src->ca_extensions)) == (struct extension *) NULL)
		return (NOTOK);

	return (OK);
}

struct security_parms	* secp_cpy (sp)
struct security_parms	* sp;
{
struct certificate_list	* cpair_cpy();
struct random_number	* random_cpy ();

	struct security_parms	* ret;

	if (sp == (struct security_parms *) NULL)
		return ((struct security_parms *) NULL);

	if ((ret = (struct security_parms *) smalloc (sizeof (struct security_parms))) == (struct security_parms *) NULL)
		return ((struct security_parms *) NULL);

	if (sp->sp_path == (struct certificate_list *) NULL)
		ret->sp_path = (struct certificate_list *) NULL;
	else if ((ret->sp_path = cpair_cpy (sp->sp_path)) == (struct certificate_list *) NULL)
		return ((struct security_parms *) NULL);

	if (sp->sp_name == NULLDN)
		ret->sp_name = NULLDN;
	else if ((ret->sp_name = dn_cpy (sp->sp_name)) == NULLDN)
		return ((struct security_parms *) NULL);

	ret->sp_time = strdup (sp->sp_time);

	if (sp->sp_random == (struct random_number *) NULL)
		ret->sp_random = (struct random_number *) NULL;
	else if ((ret->sp_random = random_cpy (sp->sp_random)) == (struct random_number *) NULL)
		return ((struct security_parms *) NULL);

	ret->sp_target = sp->sp_target;

	return (ret);
}

struct random_number	* random_cpy (rand)
struct random_number	* rand;
{
	struct random_number	* ret;

	if (rand == (struct random_number *) NULL)
		return ((struct random_number *) NULL);

	if ((ret = (struct random_number *) smalloc (sizeof (struct random_number))) == (struct random_number *) NULL)
		return ((struct random_number *) NULL);

	ret->n_bits = rand->n_bits;

	ret->value = strdup (rand->value);

	return (ret);
}

struct signature	* sig_cpy (sig)
struct signature	* sig;
{
	struct signature	* ret;

	if (sig == (struct signature *) NULL)
		return ((struct signature *) NULL);

	if ((ret = (struct signature *) smalloc (sizeof (struct signature))) == (struct signature *) NULL)
		return ((struct signature *) NULL);

	(void) alg_cpy (&ret->alg, &sig->alg);

	if (sig->encoded == NULLPE)
		ret->encoded = NULLPE;
	else
		ret->encoded = pe_cpy (sig->encoded);

	ret->n_bits = sig->n_bits;

	ret->encrypted = strdup (sig->encrypted);

	return (ret);
}

struct extension	* ext_cpy (ext)
struct extension	* ext;
{
	struct extension	* ret;

	if (ext == (struct extension *) NULL)
		return ((struct extension *) NULL);

	if ((ret = (struct extension *) smalloc (sizeof (struct extension))) == (struct extension *) NULL)
		return ((struct extension *) NULL);

	ret->ext_id = ext->ext_id;

	ret->ext_critical = ext->ext_critical;

	if (ext->ext_item == NULLPE)
		ret->ext_item = NULLPE;
	else
		ret->ext_item = pe_cpy (ext->ext_item);

	if (ext->ext_next == (struct extension *) NULL)
		ret->ext_next = (struct extension *) NULL;
	else if ((ret->ext_next = ext_cpy (ext->ext_next)) == (struct extension *) NULL)
		return ((struct extension *) NULL);

	return (ret);
}

struct s_filter	* filter_cpy(flt)
struct s_filter	* flt;
{
	struct s_filter	* ret;

	if (flt == (struct s_filter *) NULL)
		return ((struct s_filter *) NULL);

	if ((ret = (struct s_filter *) smalloc (sizeof (struct s_filter))) == (struct s_filter *) NULL)
		return ((struct s_filter *) NULL);

	switch (ret->flt_type = flt->flt_type)
	{
	case FILTER_ITEM:
		if (filter_item_dup (&(flt->flt_un.flt_un_item), &(ret->flt_un.flt_un_item)) != OK)
			return ((struct s_filter *) NULL);
		break;

	case FILTER_AND:
	case FILTER_OR:
	case FILTER_NOT:
		if (flt->flt_un.flt_un_filter == (struct s_filter *) NULL)
			ret->flt_un.flt_un_filter = (struct s_filter *) NULL;
		else if ((ret->flt_un.flt_un_filter = filter_cpy (flt->flt_un.flt_un_filter)) == (struct s_filter *) NULL)
			return ((struct s_filter *) NULL);
		break;

	default:
		DLOG (log_dsap, LLOG_DEBUG, ("filter_cpy(): unknown filter type %d", flt->flt_type));
		return ((struct s_filter *) NULL);
	}

	if (flt->flt_next == (struct s_filter *) NULL)
                ret->flt_next = (struct s_filter *) NULL;
	else if ((ret->flt_next = filter_cpy (flt->flt_next)) == (struct s_filter *) NULL)
		return ((struct s_filter *) NULL);

	return (ret);
}

int	  filter_item_dup (src, tgt)
struct filter_item	* src;
struct filter_item	* tgt;
{
	switch (tgt->fi_type = src->fi_type)
	{
	case FILTERITEM_EQUALITY:
	case FILTERITEM_GREATEROREQUAL:
	case FILTERITEM_LESSOREQUAL:
	case FILTERITEM_APPROX:
		if (ava_dup (&(src->fi_un.fi_un_ava), &(tgt->fi_un.fi_un_ava)) != OK)
			return (NOTOK);
		break;

	case FILTERITEM_PRESENT:
		if (src->fi_un.fi_un_type == NULLAttrT)
			tgt->fi_un.fi_un_type = NULLAttrT;
		else if ((tgt->fi_un.fi_un_type = AttrT_cpy (src->fi_un.fi_un_type)) == NULLAttrT)
			return (NOTOK);
		break;

	case FILTERITEM_SUBSTRINGS:
		if (fi_sub_dup (&(src->fi_un.fi_un_substrings), &(tgt->fi_un.fi_un_substrings)) != OK)
			return (NOTOK);
		break;

	default:
		DLOG (log_dsap, LLOG_DEBUG, ("filter_item_dup(): unknown filter_item type %d", src->fi_type));
		return (NOTOK);
	}

	tgt->fi_ifp = src->fi_ifp;

	return (OK);
}

int	  fi_sub_dup (src, tgt)
Filter_Substrings	* src;
Filter_Substrings	* tgt;
{
	if (src->fi_sub_type == NULLAttrT)
		tgt->fi_sub_type = NULLAttrT;
	else if ((tgt->fi_sub_type = AttrT_cpy (src->fi_sub_type)) == NULLAttrT)
		return (NOTOK);


	if (src->fi_sub_initial == NULLAV)
		tgt->fi_sub_initial = NULLAV;
	else if ((tgt->fi_sub_initial = avs_cpy (src->fi_sub_initial)) == NULLAV)
		return (NOTOK);

	if (src->fi_sub_any == NULLAV)
		tgt->fi_sub_any = NULLAV;
	else if ((tgt->fi_sub_any = avs_cpy (src->fi_sub_any)) == NULLAV)
		return (NOTOK);

	if (src->fi_sub_final == NULLAV)
		tgt->fi_sub_final = NULLAV;
	else if ((tgt->fi_sub_final = avs_cpy (src->fi_sub_final)) == NULLAV)
		return (NOTOK);

	tgt->fi_sub_match = strdup (src->fi_sub_match);

	return (OK);
}

struct entrymod	* ems_cpy(em)
struct entrymod	* em;
{
	struct entrymod	* ret;

	if (em == (struct entrymod *) NULL)
		return ((struct entrymod *) NULL);

	if ((ret = (struct entrymod *) smalloc (sizeof (struct entrymod))) == (struct entrymod *) NULL)
		return ((struct entrymod *) NULL);

	ret->em_type = em->em_type;

	if (em->em_what == NULLATTR)
		ret->em_what = NULLATTR;
	else if ((ret->em_what = as_cpy (em->em_what)) == NULLATTR)
		 return ((struct entrymod *) NULL);

	if (em->em_next == (struct entrymod *) NULL)
		ret->em_next = (struct entrymod *) NULL;
	else if ((ret->em_next = ems_cpy (em->em_next)) == (struct entrymod *) NULL)
		return ((struct entrymod *) NULL);

	return (ret);
}

int	  eis_dup(src, tgt)
struct entryinfoselection	* src;
struct entryinfoselection	* tgt;
{
	tgt->eis_allattributes = src->eis_allattributes;

        if (src->eis_select == NULLATTR)
                tgt->eis_select = NULLATTR;
        else if ((tgt->eis_select = as_cpy (src->eis_select)) == NULLATTR)
                 return (NOTOK);

	tgt->eis_infotypes = src->eis_infotypes;

	return (OK);
}

int	  ava_dup(src, tgt)
struct ava	* src;
struct ava	* tgt;
{
	if (src->ava_type == NULLAttrT)
		tgt->ava_type = NULLAttrT;
	else if ((tgt->ava_type = AttrT_cpy (src->ava_type)) == NULLAttrT)
		return (NOTOK);

	if (src->ava_value == NULLAttrV)
		tgt->ava_value = NULLAttrV;
	else if ((tgt->ava_value = AttrV_cpy (src->ava_value)) == NULLAttrV)
		return (NOTOK);

	return (OK);
}