attribute.c

ftam等标准协议服务器和客户端的源代码。

		eptr->e_lacl = as->attr_value;
	}

	if (as = entry_find_type (eptr,at_authpolicy)) {
		eptr->e_authp = (Authpolicy) as->attr_value->avseq_av.av_struct;
	}

	if (eptr->e_dsainfo != NULLDSA) /* set version number */
		if (as = entry_find_type (eptr,at_version))
			eptr->e_dsainfo->dsa_version = (char *) as->attr_value->avseq_av.av_struct;

	if (eptr->e_leaf) {
		/* still a leaf -> look for any external references */
		if (as = entry_find_type (eptr,at_xref)) {
			eptr->e_reference = as->attr_value;
			eptr->e_reftype = RT_CROSS;
			eptr->e_external = TRUE;
			eptr->e_leaf = FALSE;
			eptr->e_allchildrenpresent = FALSE;
			if (as->attr_value->avseq_next)
				pslog (log_dsap,LLOG_EXCEPTIONS,
				       "Multi valued cross reference",
				       rdn_print, (caddr_t)eptr->e_name);
		}
		if (as = entry_find_type (eptr,at_subord)) {
			if (eptr->e_external)
				pslog (log_dsap,LLOG_EXCEPTIONS,
				       "cross & subordinate reference",
				       rdn_print, (caddr_t)eptr->e_name);
			eptr->e_reference = as->attr_value;
			eptr->e_reftype = RT_SUBORDINATE;
			eptr->e_external = TRUE;
			eptr->e_leaf = FALSE;
			eptr->e_allchildrenpresent = FALSE;
			if (as->attr_value->avseq_next)
				pslog (log_dsap,LLOG_EXCEPTIONS,
				       "Multi valued subordinate reference",
				       rdn_print, (caddr_t)eptr->e_name);
		}
		if (as = entry_find_type (eptr,at_nssr)) {
			if (eptr->e_external)
				pslog (log_dsap,LLOG_EXCEPTIONS,
				       "NSSR & cross | subordinate reference",
				       rdn_print, (caddr_t)eptr->e_name);
			eptr->e_reference = as->attr_value;
			eptr->e_reftype = RT_NONSPECIFICSUBORDINATE;
			eptr->e_external = TRUE;
			eptr->e_leaf = FALSE;
			eptr->e_allchildrenpresent = FALSE;
		}
	}

	/* Make sure acl attribute exists */
	if (eptr->e_acl == (struct acl *) NULL) {
		Attr_Sequence as1;
		AV_Sequence avs1;
		AttributeValue av;

		SET_HEAP (at_acl);

		acl = acl_alloc();
		eptr->e_acl = acl;
		acl->ac_child = acl_default ();
		acl->ac_entry = acl_default ();
		acl->ac_default = acl_default ();
		acl->ac_attributes = NULLACL_ATTR;
		av = AttrV_alloc();
		av->av_syntax = acl_sntx;
		av->av_struct = (caddr_t) acl;
		avs1 = avs_comp_new (av);
		as1 = as_comp_new (AttrT_cpy(at_acl),avs1,NULLACL_INFO);
		eptr->e_attributes = as_merge(eptr->e_attributes,as1);

		RESTORE_HEAP;
	}

	/* now do the attribute acl */
	/* first of all create and oid_seq of all attribute, and point them to */
	/* the default.  */
	if (acl->ac_attributes == NULLACL_ATTR) {
		/* the easy case !!! - set every attribute to ac_default */
		for ( as = eptr->e_attributes; as != NULLATTR; as = as->attr_link) 
			as->attr_acl = acl->ac_default;
	} else {
		register struct acl_attr * aa;
		struct acl_attr * found_aa;
		register struct oid_seq * oidptr;
		char once;

		/* The following is probably in efficient */
		/* There must be a better way of setting these pointers */
		for ( as = eptr->e_attributes; as != NULLATTR; as = as->attr_link) {
			found_aa = NULLACL_ATTR;
			once = FALSE;

			for ( aa = acl->ac_attributes; aa!=NULLACL_ATTR; aa=aa->aa_next) {
				for ( oidptr=aa->aa_types;oidptr != NULLOIDSEQ; oidptr=oidptr->oid_next) {
					if (oid_cmp (oidptr->oid_oid,grab_oid(as->attr_type)) == 0) {
						if (once == TRUE)
							pslog (log_dsap,LLOG_EXCEPTIONS,
								"WARNING Inconsistent ACL in entry",
								rdn_print,
							        (caddr_t)eptr->e_name);
						else
							once = TRUE;
						found_aa = aa;
					}
				}
			}

			if (found_aa != NULLACL_ATTR) 
				/* found the apprioriate acl - add oid to it */
				as->attr_acl = found_aa->aa_acl;
			else
				as->attr_acl = acl->ac_default;
		}
	}

	if (ias = entry_find_type (eptr,at_inherit)) {
		/* set inherit ACL pointers */
		InheritAttr tmp;
		Attr_Sequence nas;

		eptr->e_inherit = avs_cpy (ias->attr_value);

		for (avs=eptr->e_inherit; avs!=NULLAV; avs=avs->avseq_next) {
			tmp = (InheritAttr) avs->avseq_av.av_struct;
			for (as = tmp->i_always; as != NULLATTR; as=as->attr_link) {
				if (  (AttrT_cmp (as->attr_type,at_acl) == 0)
				   || (AttrT_cmp (as->attr_type,at_masterdsa) == 0)
				   || (AttrT_cmp (as->attr_type,at_slavedsa) == 0)
				   || (AttrT_cmp (as->attr_type,at_relaydsa) == 0)
				   || (AttrT_cmp (as->attr_type,at_schema) == 0)
				   || (AttrT_cmp (as->attr_type,at_applctx) == 0)
				   || (AttrT_cmp (as->attr_type,at_objectclass) == 0)
				   || (AttrT_cmp (as->attr_type,at_edbinfo) == 0)
				   || (AttrT_cmp (as->attr_type,at_dsaaddress) == 0)
				   || (AttrT_cmp (as->attr_type,at_alias) == 0)
				   || (AttrT_cmp (as->attr_type,at_inherit) == 0)) {
					LLOG(log_dsap,LLOG_EXCEPTIONS,("Inherited system attribute only allowed in default case"));
					error->dse_type = DSE_ATTRIBUTEERROR;
					error->ERR_ATTRIBUTE.DSE_at_name = get_copy_dn (eptr);
					error->ERR_ATTRIBUTE.DSE_at_plist.DSE_at_what =DSE_AT_CONSTRAINTVIOLATION;
					error->ERR_ATTRIBUTE.DSE_at_plist.DSE_at_type = AttrT_cpy (as->attr_type);
					error->ERR_ATTRIBUTE.DSE_at_plist.DSE_at_value = NULLAttrV;
					error->ERR_ATTRIBUTE.DSE_at_plist.dse_at_next = DSE_AT_NOPROBLEM;
					return (DS_ERROR_REMOTE);
				   }
				as->attr_acl = ias->attr_acl;
				if (as->attr_value == NULLAV) {
					if ((nas = entry_find_type (eptr,as->attr_type)) == NULLATTR) {
						LLOG(log_dsap,LLOG_EXCEPTIONS,("Value missing for always inherited attribute type"));
					        error->dse_type = DSE_ATTRIBUTEERROR;
						error->ERR_ATTRIBUTE.DSE_at_name = get_copy_dn (eptr);
						error->ERR_ATTRIBUTE.DSE_at_plist.DSE_at_what =DSE_AT_NOSUCHATTRIBUTE;
						error->ERR_ATTRIBUTE.DSE_at_plist.DSE_at_type = AttrT_cpy (as->attr_type);
						error->ERR_ATTRIBUTE.DSE_at_plist.DSE_at_value = NULLAttrV;
						error->ERR_ATTRIBUTE.DSE_at_plist.dse_at_next = DSE_AT_NOPROBLEM;
						return (DS_ERROR_REMOTE);
					}
					as->attr_value = avs_cpy(nas->attr_value);
				}
			}
			for (as = tmp->i_default; as != NULLATTR; as=as->attr_link) {
				as->attr_acl = ias->attr_acl;
				if (as->attr_value == NULLAV) {
					if ((nas = entry_find_type (eptr,as->attr_type)) == NULLATTR) {
						LLOG(log_dsap,LLOG_EXCEPTIONS,("Value missing for default inherited attribute type"));
					        error->dse_type = DSE_ATTRIBUTEERROR;
						error->ERR_ATTRIBUTE.DSE_at_name = get_copy_dn (eptr);
						error->ERR_ATTRIBUTE.DSE_at_plist.DSE_at_what =DSE_AT_NOSUCHATTRIBUTE;
						error->ERR_ATTRIBUTE.DSE_at_plist.DSE_at_type = AttrT_cpy (as->attr_type);
						error->ERR_ATTRIBUTE.DSE_at_plist.DSE_at_value = NULLAttrV;
						error->ERR_ATTRIBUTE.DSE_at_plist.dse_at_next = DSE_AT_NOPROBLEM;
						return (DS_ERROR_REMOTE);
					}
					as->attr_value = avs_cpy(nas->attr_value);
				}
			}
		}
	}

	return (OK);
}


set_inheritance (eptr)
Entry eptr;
{
AV_Sequence avs;
InheritAttr tmp;
Attr_Sequence as;

	if ((eptr == NULLENTRY)
		|| (eptr->e_parent == NULLENTRY)
		|| (eptr->e_parent->e_inherit == NULLAV))
		return;

	eptr->e_iattr = NULLINHERIT;

	if ((eptr->e_oc == NULLAV) &&
	   ((as = entry_find_type (eptr,at_objectclass)) != NULLATTR))
		eptr->e_oc = as->attr_value;

	if (eptr->e_oc == NULLAV)
		for (avs=eptr->e_parent->e_inherit; avs != NULLAV; avs=avs->avseq_next) {
			tmp = (InheritAttr) avs->avseq_av.av_struct;
			if (tmp->i_oid == NULLOID) {
				eptr->e_iattr = tmp;
				return;
			}
		}

	/* scan through inherit atribute looking of the right object class */
	for (avs=eptr->e_parent->e_inherit; avs != NULLAV; avs=avs->avseq_next) {
		tmp = (InheritAttr) avs->avseq_av.av_struct;
		if (check_in_oc (tmp->i_oid,eptr->e_oc)) {
			eptr->e_iattr = tmp;
			return;
		}
	}
	return;

}


Attr_Sequence entry_find_type (a,b)
Entry a;
AttributeType b;
{
register int i;
register Attr_Sequence ptr;

	/* if Attr_cmp returns <0 no point in continuing due to ordering */

	for(ptr = a->e_attributes; ptr != NULLATTR; ptr=ptr->attr_link) {
		if (  (i = AttrT_cmp (ptr->attr_type,b)) <= 0)
			if ( i == 0 )
				return ptr;
			else 
				break;
	}

	if (a->e_iattr == NULLINHERIT)
		return (NULLATTR);

	for(ptr = a->e_iattr->i_default; ptr != NULLATTR; ptr=ptr->attr_link) {
		if (  (i = AttrT_cmp (ptr->attr_type,b)) <= 0)
			if ( i == 0 )
				return ptr;
			else 
				break;
	}
	for(ptr = a->e_iattr->i_always; ptr != NULLATTR; ptr=ptr->attr_link) {
		if (  (i = AttrT_cmp (ptr->attr_type,b)) <= 0)
			return (i ? NULLATTR : ptr);
	}

	return (NULLATTR);
}