*  Licensed to the Apache Software Foundation (ASF) under one

*  or more contributor license agreements.  See the NOTICE file

*  distributed with this work for additional information

*  regarding copyright ownership.  The ASF licenses this file

*  to you under the Apache License, Version 2.0 (the

*  "License"); you may not use this file except in compliance

*  with the License.  You may obtain a copy of the License at

* 

*    http://www.apache.org/licenses/LICENSE-2.0

* 

*  Unless required by applicable law or agreed to in writing,

*  software distributed under the License is distributed on an

*  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

*  KIND, either express or implied.  See the License for the

*  specific language governing permissions and limitations

*  under the License.

* 

*/

* An {@link org.apache.directory.server.core.interceptor.Interceptor} that manages and enforces schemas.

*

* @todo Better interceptor description required.

* @org.apache.xbean.XBean

*

* @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>

* @version $Rev: 918766 $, $Date: 2010-03-04 00:25:11 +0100 (Jeu, 04 mar 2010) $

*/

    /** The LoggerFactory used by this Interceptor */

    private static Logger LOG = LoggerFactory.getLogger( SchemaInterceptor.class );

    private static final String[] SCHEMA_SUBENTRY_RETURN_ATTRIBUTES = new String[]

        {

            SchemaConstants.ALL_OPERATIONAL_ATTRIBUTES,

            SchemaConstants.ALL_USER_ATTRIBUTES

        };

    /** Speedup for logs */

    private static final boolean IS_DEBUG = LOG.isDebugEnabled();

    /**

     * the root nexus to all database partitions

     */

    private PartitionNexus nexus;

    /**

     * a binary attribute tranforming filter: String -> byte[]

     */

    private BinaryAttributeFilter binaryAttributeFilter;

    private TopFilter topFilter;

    private List<EntryFilter> filters = new ArrayList<EntryFilter>();

    /** the global schema object SchemaManager */

    private SchemaManager schemaManager;

    /** A global reference to the ObjectClass attributeType */

    private AttributeType OBJECT_CLASS;

    /** A normalized form for the SubschemaSubentry DN */

    private String subschemaSubentryDnNorm;

    /** The SubschemaSubentry DN */

    private DN subschemaSubentryDn;

    /**

     * the normalized name for the schema modification attributes

     */

    private DN schemaModificationAttributesDN;

    /** The schema manager */

    private SchemaSubentryManager schemaSubEntryManager;

    private SchemaService schemaService;

    /** the base DN (normalized) of the schema partition */

    private DN schemaBaseDN;

    /** A map used to store all the objectClasses superiors */

    private Map<String, List<ObjectClass>> superiors;

    /** A map used to store all the objectClasses may attributes */

    private Map<String, List<AttributeType>> allMay;

    /** A map used to store all the objectClasses must */

    private Map<String, List<AttributeType>> allMust;

    /** A map used to store all the objectClasses allowed attributes (may + must) */

    private Map<String, List<AttributeType>> allowed;

    private static AttributeType MODIFIERS_NAME_ATTRIBUTE_TYPE;

    private static AttributeType MODIFY_TIMESTAMP_ATTRIBUTE_TYPE;

    /**

     * Initialize the Schema Service

     *

     * @param directoryService the directory service core

     * @throws Exception if there are problems during initialization

     */

    public void init( DirectoryService directoryService ) throws Exception

    {

        if ( IS_DEBUG )

        {

            LOG.debug( "Initializing SchemaInterceptor..." );

        }

        nexus = directoryService.getPartitionNexus();

        schemaManager = directoryService.getSchemaManager();

        OBJECT_CLASS = schemaManager.lookupAttributeTypeRegistry( SchemaConstants.OBJECT_CLASS_AT );

        binaryAttributeFilter = new BinaryAttributeFilter();

        topFilter = new TopFilter();

        filters.add( binaryAttributeFilter );

        filters.add( topFilter );

        schemaBaseDN = new DN( SchemaConstants.OU_SCHEMA );

        schemaBaseDN.normalize( schemaManager.getNormalizerMapping() );

        schemaService = directoryService.getSchemaService();

        // stuff for dealing with subentries (garbage for now)

        Value<?> subschemaSubentry = nexus.getRootDSE( null ).get( SchemaConstants.SUBSCHEMA_SUBENTRY_AT ).get();

        subschemaSubentryDn = new DN( subschemaSubentry.getString() );

        subschemaSubentryDn.normalize( schemaManager.getNormalizerMapping() );

        subschemaSubentryDnNorm = subschemaSubentryDn.getNormName();

        schemaModificationAttributesDN = new DN( ServerDNConstants.SCHEMA_MODIFICATIONS_DN );

        schemaModificationAttributesDN.normalize( schemaManager.getNormalizerMapping() );

        computeSuperiors();

       

        // Initialize the schema manager

        SchemaLoader loader = schemaService.getSchemaPartition().getSchemaManager().getLoader();

        schemaSubEntryManager = new SchemaSubentryManager( schemaManager, loader );

        MODIFIERS_NAME_ATTRIBUTE_TYPE = schemaManager.lookupAttributeTypeRegistry( SchemaConstants.MODIFIERS_NAME_AT );

        MODIFY_TIMESTAMP_ATTRIBUTE_TYPE = schemaManager.lookupAttributeTypeRegistry( SchemaConstants.MODIFY_TIMESTAMP_AT );

       

        if ( IS_DEBUG )

        {

            LOG.debug( "SchemaInterceptor Initialized !" );

        }

    }

    /**

     * Compute the MUST attributes for an objectClass. This method gather all the

     * MUST from all the objectClass and its superors.

     *

     * @param atSeen ???

     * @param objectClass the object class to gather MUST attributes for

     * @throws Exception if there are problems resolving schema entitites

     */

    private void computeMustAttributes( ObjectClass objectClass, Set<String> atSeen ) throws Exception

    {

        List<ObjectClass> parents = superiors.get( objectClass.getOid() );

        List<AttributeType> mustList = new ArrayList<AttributeType>();

        List<AttributeType> allowedList = new ArrayList<AttributeType>();

        Set<String> mustSeen = new HashSet<String>();

        allMust.put( objectClass.getOid(), mustList );

        allowed.put( objectClass.getOid(), allowedList );

        for ( ObjectClass parent : parents )

        {

            List<AttributeType> mustParent = parent.getMustAttributeTypes();

            if ( ( mustParent != null ) && ( mustParent.size() != 0 ) )

            {

                for ( AttributeType attributeType : mustParent )

                {

                    String oid = attributeType.getOid();

                    if ( !mustSeen.contains( oid ) )

                    {

                        mustSeen.add( oid );

                        mustList.add( attributeType );

                        allowedList.add( attributeType );

                        atSeen.add( attributeType.getOid() );

                    }

                }

            }

        }

    }

    /**

     * Compute the MAY attributes for an objectClass. This method gather all the

     * MAY from all the objectClass and its superors.

     *

     * The allowed attributes is also computed, it's the union of MUST and MAY

     *

     * @param atSeen ???

     * @param objectClass the object class to get all the MAY attributes for

     * @throws Exception with problems accessing registries

     */

    private void computeMayAttributes( ObjectClass objectClass, Set<String> atSeen ) throws Exception

    {

        List<ObjectClass> parents = superiors.get( objectClass.getOid() );

        List<AttributeType> mayList = new ArrayList<AttributeType>();

        Set<String> maySeen = new HashSet<String>();

        List<AttributeType> allowedList = allowed.get( objectClass.getOid() );

        allMay.put( objectClass.getOid(), mayList );

        for ( ObjectClass parent : parents )

        {

            List<AttributeType> mustParent = parent.getMustAttributeTypes();

            if ( ( mustParent != null ) && ( mustParent.size() != 0 ) )

            {

                for ( AttributeType attributeType : mustParent )

                {

                    String oid = attributeType.getOid();

                    if ( !maySeen.contains( oid ) )

                    {

                        maySeen.add( oid );

                        mayList.add( attributeType );

                        if ( !atSeen.contains( oid ) )

                        {

                            allowedList.add( attributeType );

                        }

                    }

                }

            }

        }

    }

    /**

     * Recursively compute all the superiors of an object class. For instance, considering

     * 'inetOrgPerson', it's direct superior is 'organizationalPerson', which direct superior

     * is 'Person', which direct superior is 'top'.

     *

     * As a result, we will gather all of these three ObjectClasses in 'inetOrgPerson' ObjectClasse

     * superiors.

     */

    private void computeOCSuperiors( ObjectClass objectClass, List<ObjectClass> superiors, Set<String> ocSeen )

        throws Exception

    {

        List<ObjectClass> parents = objectClass.getSuperiors();

        // Loop on all the objectClass superiors

        if ( ( parents != null ) && ( parents.size() != 0 ) )

        {

            for ( ObjectClass parent : parents )

            {

                // Top is not added

                if ( SchemaConstants.TOP_OC.equals( parent.getName() ) )

                {

                    continue;

                }

                // For each one, recurse

                computeOCSuperiors( parent, superiors, ocSeen );

                String oid = parent.getOid();

                if ( !ocSeen.contains( oid ) )

                {

                    superiors.add( parent );

                    ocSeen.add( oid );

                }

            }

        }

    }

    /**

     * Compute the superiors and MUST/MAY attributes for a specific

     * ObjectClass

     */

    private void computeSuperior( ObjectClass objectClass ) throws Exception

    {

        List<ObjectClass> ocSuperiors = new ArrayList<ObjectClass>();

        superiors.put( objectClass.getOid(), ocSuperiors );

        computeOCSuperiors( objectClass, ocSuperiors, new HashSet<String>() );

        Set<String> atSeen = new HashSet<String>();

        computeMustAttributes( objectClass, atSeen );

        computeMayAttributes( objectClass, atSeen );

        superiors.put( objectClass.getName(), ocSuperiors );

    }

   

    /**

     * Compute all ObjectClasses superiors, MAY and MUST attributes.

     * @throws Exception

     */

    private void computeSuperiors() throws Exception

    {

        Iterator<ObjectClass> objectClasses = schemaManager.getObjectClassRegistry().iterator();

        superiors = new ConcurrentHashMap<String, List<ObjectClass>>();

        allMust = new ConcurrentHashMap<String, List<AttributeType>>();

        allMay = new ConcurrentHashMap<String, List<AttributeType>>();

        allowed = new ConcurrentHashMap<String, List<AttributeType>>();

        while ( objectClasses.hasNext() )

        {

            ObjectClass objectClass = objectClasses.next();

            computeSuperior( objectClass );

        }

    }

    public EntryFilteringCursor list( NextInterceptor nextInterceptor, ListOperationContext opContext )

        throws Exception

    {

        EntryFilteringCursor cursor = nextInterceptor.list( opContext );

        cursor.addEntryFilter( binaryAttributeFilter );

        return cursor;

    }

    /**

     * Remove all unknown attributes from the searchControls, to avoid an exception.

     *

     * RFC 2251 states that :

     * " Attributes MUST be named at most once in the list, and are returned "

     * " at most once in an entry. "

     * " If there are attribute descriptions in "

     * " the list which are not recognized, they are ignored by the server."

     *

     * @param searchCtls The SearchControls we will filter

     */

    private void filterAttributesToReturn( SearchControls searchCtls )

    {

        String[] attributes = searchCtls.getReturningAttributes();

        if ( ( attributes == null ) || ( attributes.length == 0 ) )

        {

            // We have no attributes, that means "*" (all users attributes)

            searchCtls.setReturningAttributes( SchemaConstants.ALL_USER_ATTRIBUTES_ARRAY );

            return;

        }

        Map<String, String> filteredAttrs = new HashMap<String, String>();

        boolean hasNoAttribute = false;

        boolean hasAttributes = false;

        for ( String attribute : attributes )

        {

            // Skip special attributes

            if ( ( SchemaConstants.ALL_USER_ATTRIBUTES.equals( attribute ) )

                || ( SchemaConstants.ALL_OPERATIONAL_ATTRIBUTES.equals( attribute ) )

                || ( SchemaConstants.NO_ATTRIBUTE.equals( attribute ) ) )

            {

                if ( !filteredAttrs.containsKey( attribute ) )

                {

                    filteredAttrs.put( attribute, attribute );

                }

                if ( SchemaConstants.NO_ATTRIBUTE.equals( attribute ) )

                {

                    hasNoAttribute = true;

                }

                else

                {

                    hasAttributes = true;

                }

                continue;

            }

            try

            {

                // Check that the attribute is declared

                if ( schemaManager.getAttributeTypeRegistry().contains( attribute ) )

                {

                    String oid = schemaManager.getAttributeTypeRegistry().getOidByName( attribute );

                    // The attribute must be an AttributeType

                    if ( schemaManager.getAttributeTypeRegistry().contains( oid ) )

                    {

                        if ( !filteredAttrs.containsKey( oid ) )

                        {

                            // Ok, we can add the attribute to the list of filtered attributes

                            filteredAttrs.put( oid, attribute );

                        }

                    }

                }

                hasAttributes = true;

            }

            catch ( Exception ne )

            {

                /* Do nothing, the attribute does not exist */

            }

        }

        // Treat a special case : if we have an attribute and "1.1", then discard "1.1"

        if ( hasAttributes && hasNoAttribute )

        {

            filteredAttrs.remove( SchemaConstants.NO_ATTRIBUTE );

        }

        // If we still have the same attribute number, then we can just get out the method

        if ( filteredAttrs.size() == attributes.length )

        {

            return;

        }

        // Deal with the special case where the attribute list is now empty

        if ( filteredAttrs.size() == 0 )

        {

            // We just have to pass the special 1.1 attribute,

            // as we don't want to return any attribute

            searchCtls.setReturningAttributes( SchemaConstants.NO_ATTRIBUTE_ARRAY );

            return;

        }

        // Some attributes have been removed. let's modify the searchControl

        String[] newAttributesList = new String[filteredAttrs.size()];

        int pos = 0;

        for ( String key : filteredAttrs.keySet() )

        {

            newAttributesList[pos++] = filteredAttrs.get( key );

        }

        searchCtls.setReturningAttributes( newAttributesList );

    }

    private Value<?> convert( String id, Object value ) throws Exception

    {

        AttributeType at = schemaManager.lookupAttributeTypeRegistry( id );

        if ( at.getSyntax().isHumanReadable() )

        {

            if ( value instanceof byte[] )

            {

                try

                {

                    return new ClientStringValue( new String( ( byte[] ) value, "UTF-8" ) );

                }

                catch ( UnsupportedEncodingException uee )

                {

                    String message = I18n.err( I18n.ERR_47 );

                    LOG.error( message );

                    throw new NamingException( message );

                }

            }

        }

        else

        {

            if ( value instanceof String )

            {

                try

                {

                    return new ClientBinaryValue( ( ( String ) value ).getBytes( "UTF-8" ) );

                }

                catch ( UnsupportedEncodingException uee )

                {

                    String message = I18n.err( I18n.ERR_48 );

                    LOG.error( message );

                    throw new NamingException( message );

                }

            }

        }

        return null;

    }

    /**

     * Check that the filter values are compatible with the AttributeType. Typically,

     * a HumanReadible filter should have a String value. The substring filter should

     * not be used with binary attributes.

     */

    private void checkFilter( ExprNode filter ) throws Exception

    {

        if ( filter == null )

        {

            String message = I18n.err( I18n.ERR_49 );

            LOG.error( message );

            throw new NamingException( message );

        }

        if ( filter.isLeaf() )

        {

            if ( filter instanceof EqualityNode )

            {

                EqualityNode node = ( ( EqualityNode ) filter );

                Object value = node.getValue();

                Value<?> newValue = convert( node.getAttribute(), value );

                if ( newValue != null )

                {

                    node.setValue( newValue );

                }

            }

            else if ( filter instanceof SubstringNode )

            {

                SubstringNode node = ( ( SubstringNode ) filter );

                if ( !schemaManager.lookupAttributeTypeRegistry( node.getAttribute() ).getSyntax().isHumanReadable() )

                {

                    String message = I18n.err( I18n.ERR_50 );

                    LOG.error( message );

                    throw new NamingException( message );

                }

            }

            else if ( filter instanceof PresenceNode )

            {

                // Nothing to do

            }

            else if ( filter instanceof GreaterEqNode )

            {

                GreaterEqNode node = ( ( GreaterEqNode ) filter );

                Object value = node.getValue();

                Value<?> newValue = convert( node.getAttribute(), value );

                if ( newValue != null )

                {

                    node.setValue( newValue );

                }

            }

            else if ( filter instanceof LessEqNode )

            {

                LessEqNode node = ( ( LessEqNode ) filter );

                Object value = node.getValue();

                Value<?> newValue = convert( node.getAttribute(), value );

                if ( newValue != null )

                {

                    node.setValue( newValue );

                }

            }

            else if ( filter instanceof ExtensibleNode )

            {

                ExtensibleNode node = ( ( ExtensibleNode ) filter );

                if ( !schemaManager.lookupAttributeTypeRegistry( node.getAttribute() ).getSyntax().isHumanReadable() )

                {

                    String message = I18n.err( I18n.ERR_51 );

                    LOG.error( message );

                    throw new NamingException( message );

                }

            }

            else if ( filter instanceof ApproximateNode )

            {

                ApproximateNode node = ( ( ApproximateNode ) filter );

                Object value = node.getValue();

                Value<?> newValue = convert( node.getAttribute(), value );

                if ( newValue != null )

                {

                    node.setValue( newValue );

                }

            }

            else if ( filter instanceof AssertionNode )

            {

                // Nothing to do

                return;

            }

            else if ( filter instanceof ScopeNode )

            {

                // Nothing to do

                return;

            }

        }

        else

        {

            // Recursively iterate through all the children.

            for ( ExprNode child : ( ( BranchNode ) filter ).getChildren() )

            {

                checkFilter( child );

            }

        }

    }

    public EntryFilteringCursor search( NextInterceptor nextInterceptor, SearchOperationContext opContext )

        throws Exception

    {

        DN base = opContext.getDn();

        SearchControls searchCtls = opContext.getSearchControls();

        ExprNode filter = opContext.getFilter();

        // We have to eliminate bad attributes from the request, accordingly

        // to RFC 2251, chap. 4.5.1. Basically, all unknown attributes are removed

        // from the list

        if ( searchCtls.getReturningAttributes() != null )

        {

            filterAttributesToReturn( searchCtls );

        }

        // We also have to check the H/R flag for the filter attributes

        checkFilter( filter );

        String baseNormForm = ( base.isNormalized() ? base.getNormName() : base.toNormName() );

        // Deal with the normal case : searching for a normal value (not subSchemaSubEntry)

        if ( !subschemaSubentryDnNorm.equals( baseNormForm ) )

        {

            EntryFilteringCursor cursor = nextInterceptor.search( opContext );

            if ( searchCtls.getReturningAttributes() != null )

            {

                cursor.addEntryFilter( topFilter );

                return cursor;

            }

            for ( EntryFilter ef : filters )

            {

                cursor.addEntryFilter( ef );

            }

            return cursor;

        }

        // The user was searching into the subSchemaSubEntry

        // This kind of search _must_ be limited to OBJECT scope (the subSchemaSubEntry

        // does not have any sub level)

        if ( searchCtls.getSearchScope() == SearchControls.OBJECT_SCOPE )

        {

            // The filter can be an equality or a presence, but nothing else

            if ( filter instanceof SimpleNode )

            {

                // We should get the value for the filter.

                // only 'top' and 'subSchema' are valid values

                SimpleNode node = ( SimpleNode ) filter;

                String objectClass;

                objectClass = node.getValue().getString();

                String objectClassOid = null;

                if ( schemaManager.getObjectClassRegistry().contains( objectClass ) )

                {

                    objectClassOid = schemaManager.getObjectClassRegistry().lookup( objectClass ).getOid();

                }

                else

                {

                    return new BaseEntryFilteringCursor( new EmptyCursor<ServerEntry>(), opContext );

                }

                String nodeOid = schemaManager.getAttributeTypeRegistry().getOidByName( node.getAttribute() );

                // see if node attribute is objectClass

                if ( nodeOid.equals( SchemaConstants.OBJECT_CLASS_AT_OID )

                    && ( objectClassOid.equals( SchemaConstants.TOP_OC_OID ) || objectClassOid

                        .equals( SchemaConstants.SUBSCHEMA_OC_OID ) ) && ( node instanceof EqualityNode ) )

                {

                    // call.setBypass( true );

                    ServerEntry serverEntry = schemaService.getSubschemaEntry( searchCtls.getReturningAttributes() );

                    serverEntry.setDn( base );

                    return new BaseEntryFilteringCursor( new SingletonCursor<ServerEntry>( serverEntry ), opContext );

                }

                else

                {

                    return new BaseEntryFilteringCursor( new EmptyCursor<ServerEntry>(), opContext );

                }

            }

            else if ( filter instanceof PresenceNode )

            {

                PresenceNode node = ( PresenceNode ) filter;

                // see if node attribute is objectClass

                if ( node.getAttribute().equals( SchemaConstants.OBJECT_CLASS_AT_OID ) )

                {

                    // call.setBypass( true );

                    ServerEntry serverEntry = schemaService.getSubschemaEntry( searchCtls.getReturningAttributes() );

                    serverEntry.setDn( base );

                    EntryFilteringCursor cursor = new BaseEntryFilteringCursor( new SingletonCursor<ServerEntry>(

                        serverEntry ), opContext );

                    return cursor;

                }

            }

        }

        // In any case not handled previously, just return an empty result

        return new BaseEntryFilteringCursor( new EmptyCursor<ServerEntry>(), opContext );

    }

    /**

     * Search for an entry, using its DN. Binary attributes and ObjectClass attribute are removed.

     */

    public ClonedServerEntry lookup( NextInterceptor nextInterceptor, LookupOperationContext opContext )

        throws Exception

    {

        ClonedServerEntry result = nextInterceptor.lookup( opContext );

        if ( result == null )

        {

            return null;

        }

        filterBinaryAttributes( result );

        filterObjectClass( result );

        return result;

    }

    private void getSuperiors( ObjectClass oc, Set<String> ocSeen, List<ObjectClass> result ) throws Exception

    {

        for ( ObjectClass parent : oc.getSuperiors() )

        {

            // Skip 'top'

            if ( SchemaConstants.TOP_OC.equals( parent.getName() ) )

            {

                continue;

            }

            if ( !ocSeen.contains( parent.getOid() ) )

            {

                ocSeen.add( parent.getOid() );

                result.add( parent );

            }

            // Recurse on the parent

            getSuperiors( parent, ocSeen, result );

        }

    }

    /**

     * Checks to see if an attribute is required by as determined from an entry's

     * set of objectClass attribute values.

     *

     * @param attrId the attribute to test if required by a set of objectClass values

     * @param objectClass the objectClass values

     * @return true if the objectClass values require the attribute, false otherwise

     * @throws Exception if the attribute is not recognized

     */

    private boolean isRequired( String attrId, EntryAttribute objectClasses ) throws Exception

    {

        OidRegistry oidRegistry = schemaManager.getGlobalOidRegistry();

        if ( !oidRegistry.contains( attrId ) )

        {

            return false;

        }

        String attrOid = schemaManager.getAttributeTypeRegistry().getOidByName( attrId );

        for ( Value<?> objectClass : objectClasses )

        {

            ObjectClass ocSpec = schemaManager.getObjectClassRegistry().lookup( objectClass.getString() );

            for ( AttributeType must : ocSpec.getMustAttributeTypes() )

            {

                if ( must.getOid().equals( attrOid ) )

                {

                    return true;

                }

            }

        }

        return false;

    }

    /**

     * Checks to see if removing a set of attributes from an entry completely removes

     * that attribute's values.  If change has zero size then all attributes are

     * presumed to be removed.

     *

     * @param change

     * @param entry

     * @return

     * @throws Exception

     */

    private boolean isCompleteRemoval( ServerAttribute change, ServerEntry entry ) throws Exception

    {

        // if change size is 0 then all values are deleted then we're in trouble

        if ( change.size() == 0 )

        {

            return true;

        }

        // can't do math to figure our if all values are removed since some

        // values in the modify request may not be in the entry.  we need to

        // remove the values from a cloned version of the attribute and see

        // if nothing is left.

        ServerAttribute changedEntryAttr = ( ServerAttribute ) entry.get( change.getUpId() ).clone();

        for ( Value<?> value : change )

        {

            changedEntryAttr.remove( value );

        }

        return changedEntryAttr.size() == 0;

    }

    /**

     *

     * @param modOp

     * @param changes

     * @param existing

     * @return

     * @throws Exception

     */

    private EntryAttribute getResultantObjectClasses( ModificationOperation modOp, EntryAttribute changes,

        EntryAttribute existing ) throws Exception

    {

        if ( ( changes == null ) && ( existing == null ) )

        {

            return new DefaultServerAttribute( SchemaConstants.OBJECT_CLASS_AT, OBJECT_CLASS );

        }

        if ( changes == null )

        {

            return existing;

        }

        if ( ( existing == null ) && ( modOp == ModificationOperation.ADD_ATTRIBUTE ) )

        {

            return changes;

        }

        else if ( existing == null )

        {

            return new DefaultServerAttribute( SchemaConstants.OBJECT_CLASS_AT, OBJECT_CLASS );

        }

        switch ( modOp )

        {

            case ADD_ATTRIBUTE:

                for ( Value<?> value : changes )

                {

                    existing.add( value );

                }

                return existing;

            case REPLACE_ATTRIBUTE:

                return ( ServerAttribute ) changes.clone();

            case REMOVE_ATTRIBUTE:

                for ( Value<?> value : changes )

                {

                    existing.remove( value );

                }

                return existing;

            default:

                throw new InternalError( "" );

        }

    }

    private boolean getObjectClasses( EntryAttribute objectClasses, List<ObjectClass> result ) throws Exception

    {

        Set<String> ocSeen = new HashSet<String>();

        // We must select all the ObjectClasses, except 'top',

        // but including all the inherited ObjectClasses

        boolean hasExtensibleObject = false;

        for ( Value<?> objectClass : objectClasses )

        {

            String objectClassName = objectClass.getString();

            if ( SchemaConstants.TOP_OC.equals( objectClassName ) )

            {

                continue;

            }

            if ( SchemaConstants.EXTENSIBLE_OBJECT_OC.equalsIgnoreCase( objectClassName ) )

            {

                hasExtensibleObject = true;

            }

            ObjectClass oc = schemaManager.getObjectClassRegistry().lookup( objectClassName );

            // Add all unseen objectClasses to the list, except 'top'

            if ( !ocSeen.contains( oc.getOid() ) )

            {

                ocSeen.add( oc.getOid() );

                result.add( oc );

            }

            // Find all current OC parents

            getSuperiors( oc, ocSeen, result );

        }

        return hasExtensibleObject;

    }

    private Set<String> getAllMust( EntryAttribute objectClasses ) throws Exception

    {

        Set<String> must = new HashSet<String>();

        // Loop on all objectclasses

        for ( Value<?> value : objectClasses )

        {

            String ocName = value.getString();

            ObjectClass oc = schemaManager.getObjectClassRegistry().lookup( ocName );

            List<AttributeType> types = oc.getMustAttributeTypes();

            // For each objectClass, loop on all MUST attributeTypes, if any

            if ( ( types != null ) && ( types.size() > 0 ) )

            {

                for ( AttributeType type : types )

                {

                    must.add( type.getOid() );

                }

            }

        }

        return must;

    }

    private Set<String> getAllAllowed( EntryAttribute objectClasses, Set<String> must ) throws Exception

    {

        Set<String> allowed = new HashSet<String>( must );

        // Add the 'ObjectClass' attribute ID

        allowed.add( schemaManager.getAttributeTypeRegistry().getOidByName( SchemaConstants.OBJECT_CLASS_AT ) );

        // Loop on all objectclasses

        for ( Value<?> objectClass : objectClasses )

        {

            String ocName = objectClass.getString();

            ObjectClass oc = schemaManager.getObjectClassRegistry().lookup( ocName );

            List<AttributeType> types = oc.getMayAttributeTypes();

            // For each objectClass, loop on all MAY attributeTypes, if any

            if ( ( types != null ) && ( types.size() > 0 ) )

            {

                for ( AttributeType type : types )

                {

                    String oid = type.getOid();

                    allowed.add( oid );

                }

            }

        }

        return allowed;

    }

    /**

     * Given the objectClasses for an entry, this method adds missing ancestors

     * in the hierarchy except for top which it removes.  This is used for this

     * solution to DIREVE-276.  More information about this solution can be found

     * <a href="http://docs.safehaus.org:8080/x/kBE">here</a>.

     *

     * @param objectClassAttr the objectClass attribute to modify

     * @throws Exception if there are problems

     */

    private void alterObjectClasses( EntryAttribute objectClassAttr ) throws Exception

    {

        Set<String> objectClasses = new HashSet<String>();

        Set<String> objectClassesUP = new HashSet<String>();

        // Init the objectClass list with 'top'

        objectClasses.add( SchemaConstants.TOP_OC );

        objectClassesUP.add( SchemaConstants.TOP_OC );

        // Construct the new list of ObjectClasses

        for ( Value<?> ocValue : objectClassAttr )

        {

            String ocName = ocValue.getString();

            if ( !ocName.equalsIgnoreCase( SchemaConstants.TOP_OC ) )

            {

                String ocLowerName = ocName.toLowerCase();

                ObjectClass objectClass = schemaManager.getObjectClassRegistry().lookup( ocLowerName );

                if ( !objectClasses.contains( ocLowerName ) )

                {

                    objectClasses.add( ocLowerName );

                    objectClassesUP.add( ocName );

                }

                List<ObjectClass> ocSuperiors = superiors.get( objectClass.getOid() );

                if ( ocSuperiors != null )

                {

                    for ( ObjectClass oc : ocSuperiors )

                    {

                        if ( !objectClasses.contains( oc.getName().toLowerCase() ) )

                        {

                            objectClasses.add( oc.getName() );

                            objectClassesUP.add( oc.getName() );

                        }

                    }

                }

            }

        }

        // Now, reset the ObjectClass attribute and put the new list into it

        objectClassAttr.clear();

        for ( String attribute : objectClassesUP )

        {

            objectClassAttr.add( attribute );

        }

    }

    public void rename( NextInterceptor next, RenameOperationContext opContext ) throws Exception

    {

        DN oldDn = opContext.getDn();

        RDN newRdn = opContext.getNewRdn();

        boolean deleteOldRn = opContext.getDelOldDn();

        ServerEntry entry =  (ServerEntry)opContext.getEntry().getClonedEntry();

        /*

         *  Note: This is only a consistency checks, to the ensure that all

         *  mandatory attributes are available after deleting the old RDN.

         *  The real modification is done in the XdbmStore class.

         *  - TODO: this check is missing in the moveAndRename() method

         */

        if ( deleteOldRn )

        {

            ServerEntry tmpEntry = ( ServerEntry ) entry.clone();

            RDN oldRDN = oldDn.getRdn();

            // Delete the old RDN means we remove some attributes and values.

            // We must make sure that after this operation all must attributes

            // are still present in the entry.

            for ( AVA atav : oldRDN )

            {

                AttributeType type = schemaManager.lookupAttributeTypeRegistry( atav.getUpType() );

                tmpEntry.remove( type, atav.getUpValue() );

            }

           

            for ( AVA atav : newRdn )

            {

                AttributeType type = schemaManager.lookupAttributeTypeRegistry( atav.getUpType() );

                if ( !tmpEntry.contains( type, atav.getNormValue() ) )

                {

                    tmpEntry.add( new DefaultServerAttribute( type, atav.getUpValue() ) );

                }

            }

            // Substitute the RDN and check if the new entry is correct

            tmpEntry.setDn( opContext.getNewDn() );

            check( opContext.getNewDn(), tmpEntry );

            // Check that no operational attributes are removed

            for ( AVA atav : oldRDN )

            {

                AttributeType attributeType = schemaManager.lookupAttributeTypeRegistry( atav.getUpType() );

                if ( !attributeType.isUserModifiable() )

                {

                    throw new NoPermissionException( "Cannot modify the attribute '" + atav.getUpType() + "'" );

                }

            }

        }

        next.rename( opContext );

    }

    /**

     * Create a new attribute using the given values

     */

    private EntryAttribute createNewAttribute( ServerAttribute attribute )

    {

        AttributeType attributeType = attribute.getAttributeType();

       

        // Create the new Attribute

        EntryAttribute newAttribute = new DefaultServerAttribute( attribute.getUpId(), attributeType );