ldap/codec/core/src/main/java/org/apache/directory/api/ldap/codec/factory/SearchRequestFactory.java

/*
 *  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
 *
 *    https://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.
 *
 */
package org.apache.directory.api.ldap.codec.factory;

import java.util.Iterator;
import java.util.List;

import org.apache.directory.api.asn1.ber.tlv.BerValue;
import org.apache.directory.api.asn1.util.Asn1Buffer;
import org.apache.directory.api.ldap.codec.api.LdapApiService;
import org.apache.directory.api.ldap.codec.api.LdapCodecConstants;
import org.apache.directory.api.ldap.model.filter.AndNode;
import org.apache.directory.api.ldap.model.filter.ApproximateNode;
import org.apache.directory.api.ldap.model.filter.BranchNode;
import org.apache.directory.api.ldap.model.filter.EqualityNode;
import org.apache.directory.api.ldap.model.filter.ExprNode;
import org.apache.directory.api.ldap.model.filter.ExtensibleNode;
import org.apache.directory.api.ldap.model.filter.GreaterEqNode;
import org.apache.directory.api.ldap.model.filter.LessEqNode;
import org.apache.directory.api.ldap.model.filter.NotNode;
import org.apache.directory.api.ldap.model.filter.OrNode;
import org.apache.directory.api.ldap.model.filter.PresenceNode;
import org.apache.directory.api.ldap.model.filter.SimpleNode;
import org.apache.directory.api.ldap.model.filter.SubstringNode;
import org.apache.directory.api.ldap.model.message.Message;
import org.apache.directory.api.ldap.model.message.SearchRequest;
import org.apache.directory.api.util.Strings;

/**
 * The SearchRequest factory.
 *
 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
 */
public final class SearchRequestFactory implements Messagefactory
{
    /** The static instance */
    public static final SearchRequestFactory INSTANCE = new SearchRequestFactory();

    private SearchRequestFactory()
    {
        // Nothing to do
    }

    /**
     * Recursively encode the children of a connector node (AND, OR, NOT)
     *
     * @param buffer The buffer where to put the PDU
     * @param children The children to encode
     */
    private void encodeFilters( Asn1Buffer buffer, Iterator<ExprNode> children )
    {
        if ( children.hasNext() )
        {
            ExprNode child = children.next();

            // Recurse
            encodeFilters( buffer, children );

            // And finally the child, at the right position
            encodeFilter( buffer, child );
        }
    }


    /**
     * Encode a BranchNode.
     * <br>
     * BranchFilter :
     * <pre>
     * 0xA1/0xA2/0xA3 LL
     *  filter.encode() ... filter.encode()
     * </pre>
     *
     * @param buffer The buffer where to put the PDU
     * @param node The Branch filter to encode
     * @param tag the ASN.1 type
     */
    private void encodeFilter( Asn1Buffer buffer, BranchNode node, byte tag )
    {
        int start = buffer.getPos();

        // encode each filter
        List<ExprNode> children = node.getChildren();

        if ( ( children != null ) && ( !children.isEmpty() ) )
        {
            encodeFilters( buffer, children.iterator() );
        }

        // The BranchNode sequence
        BerValue.encodeSequence( buffer, tag, start );
    }


    /**
     * Encode a SimpleNode.
     * <br>
     * SimpleFilter :
     * <pre>
     * 0xA3/0xA5/0xA6/A8 LL
     *   0x04 LL attributeDesc
     *   0x04 LL assertionValue
     * </pre>
     *
     * @param buffer The buffer where to put the PDU
     * @param node The Simple filter to encode
     * @param tag the ASN.1 type
     */
    private void encodeFilter( Asn1Buffer buffer, SimpleNode<?> node, byte tag )
    {
        int start = buffer.getPos();

        // The attribute desc
        BerValue.encodeOctetString( buffer, node.getValue().getBytes() );

        // The assertion desc
        BerValue.encodeOctetString( buffer, node.getAttribute() );

        // The EqualityNode sequence
        BerValue.encodeSequence( buffer, tag, start );
    }


    /**
     * Encode a PresenceNode.
     * <br>
     * PresentFilter :
     * <pre>
     * 0x87 L1 present
     * </pre>
     *
     * @param buffer The buffer where to put the PDU
     * @param node The Presence filter to encode
     */
    private void encodeFilter( Asn1Buffer buffer, PresenceNode node )
    {
        // The PresentFilter Tag
        BerValue.encodeOctetString( buffer, ( byte ) LdapCodecConstants.PRESENT_FILTER_TAG,
            Strings.getBytesUtf8( node.getAttribute() ) );
    }


    /**
     * Encode a SubstringNode.
     * <br>
     * Substrings Filter :
     * <pre>
     * 0xA4 LL
     *   0x04 LL type
     *   0x30 LL substrings sequence
     *    |  0x80 LL initial
     *    | /  [0x81 LL any]*
     *    |/   [0x82 LL final]
     *    +--[0x81 LL any]+
     *     \   [0x82 LL final]
     *      \
     *       0x82 LL final
     * </pre>
     *
     * @param buffer The buffer where to put the PDU
     * @param node The Substring filter to encode
     */
    private void encodeFilter( Asn1Buffer buffer, SubstringNode node )
    {
        int start = buffer.getPos();

        // The final
        if ( node.getFinal() != null )
        {
            BerValue.encodeOctetString( buffer, ( byte ) LdapCodecConstants.SUBSTRINGS_FILTER_FINAL_TAG,
                Strings.getBytesUtf8( node.getFinal() ) );
        }

        // The any
        List<String> any = node.getAny();

        if ( any != null )
        {
            for ( int i = any.size(); i > 0; i-- )
            {
                BerValue.encodeOctetString( buffer, ( byte ) LdapCodecConstants.SUBSTRINGS_FILTER_ANY_TAG,
                    Strings.getBytesUtf8( any.get( i - 1 ) ) );
            }
        }

        // The initial
        if ( node.getInitial() != null )
        {
            BerValue.encodeOctetString( buffer, ( byte ) LdapCodecConstants.SUBSTRINGS_FILTER_INITIAL_TAG,
                Strings.getBytesUtf8( node.getInitial() ) );
        }

        // The Substring sequence
        BerValue.encodeSequence( buffer, start );

        // The type
        BerValue.encodeOctetString( buffer, node.getAttribute() );

        // The EqualityNode sequence
        BerValue.encodeSequence( buffer, ( byte ) LdapCodecConstants.SUBSTRINGS_FILTER_TAG, start );
    }


    /**
     * Encode an ExtensibleNode.
     * <br>
     * ExtensibleMatch filter :
     * <pre>
     * 0xA9 L1
     *   |
     *  [+--&gt; 0x81 L3 matchingRule]
     *  [+--&gt; 0x82 L4 type]
     *  [+--&gt; 0x83 L5 matchValue]
     *  [+--&gt; 0x01 0x01 dnAttributes]
     * </pre>
     *
     * @param buffer The buffer where to put the PDU
     * @param node The ExtensibleMatch filter to encode
     */
    private void encodeFilter( Asn1Buffer buffer, ExtensibleNode node )
    {
        int start = buffer.getPos();

        // The dnAttributes flag, if true only
        if ( node.hasDnAttributes() )
        {
            BerValue.encodeBoolean( buffer, ( byte ) LdapCodecConstants.DN_ATTRIBUTES_FILTER_TAG, true );
        }

        // The matching value
        if ( node.getValue() != null )
        {
            BerValue.encodeOctetString( buffer, ( byte ) LdapCodecConstants.MATCH_VALUE_TAG,
                node.getValue().getBytes() );
        }

        // The type
        if ( node.getAttribute() != null )
        {
            BerValue.encodeOctetString( buffer, ( byte ) LdapCodecConstants.MATCHING_RULE_TYPE_TAG,
                Strings.getBytesUtf8( node.getAttribute() ) );
        }

        // The matching rule
        if ( node.getMatchingRuleId() != null )
        {
            BerValue.encodeOctetString( buffer, ( byte ) LdapCodecConstants.MATCHING_RULE_ID_TAG,
                Strings.getBytesUtf8( node.getMatchingRuleId() ) );
        }

        // The EqualityNode sequence
        BerValue.encodeSequence( buffer, ( byte ) LdapCodecConstants.EXTENSIBLE_MATCH_FILTER_TAG, start );
    }


    /**
     * Encode a Search Filter
     *
     * @param buffer The buffer where to put the PDU
     * @param node The top filter
     */
    private void encodeFilter( Asn1Buffer buffer, ExprNode node )
    {
        switch ( node.getClass().getSimpleName() )
        {
            case "AndNode" :
                encodeFilter( buffer, ( AndNode ) node, ( byte ) LdapCodecConstants.AND_FILTER_TAG );
                break;

            case "ApproximateNode" :
                encodeFilter( buffer, ( ApproximateNode<?> ) node, ( byte ) LdapCodecConstants.APPROX_MATCH_FILTER_TAG );
                break;

            case "EqualityNode" :
                encodeFilter( buffer, ( EqualityNode<?> ) node, ( byte ) LdapCodecConstants.EQUALITY_MATCH_FILTER_TAG );
                break;

            case "ExtensibleNode" :
                encodeFilter( buffer, ( ExtensibleNode ) node );
                break;

            case "GreaterEqNode" :
                encodeFilter( buffer, ( GreaterEqNode<?> ) node, ( byte ) LdapCodecConstants.GREATER_OR_EQUAL_FILTER_TAG );
                break;

            case "LessEqNode" :
                encodeFilter( buffer, ( LessEqNode<?> ) node, ( byte ) LdapCodecConstants.LESS_OR_EQUAL_FILTER_TAG );
                break;

            case "NotNode" :
                encodeFilter( buffer, ( NotNode ) node, ( byte ) LdapCodecConstants.NOT_FILTER_TAG );
                break;

            case "OrNode" :
                encodeFilter( buffer, ( OrNode ) node, ( byte ) LdapCodecConstants.OR_FILTER_TAG );
                break;

            case "PresenceNode" :
                encodeFilter( buffer, ( PresenceNode ) node );
                break;

            case "SubstringNode" :
                encodeFilter( buffer, ( SubstringNode ) node );
                break;

            default:
                break;
        }
    }

    /**
     * Encode the SearchRequest message to a PDU.
     * <br>
     * SearchRequest :
     * <pre>
     * 0x63 LL
     *   0x04 LL baseObject
     *   0x0A 01 scope
     *   0x0A 01 derefAliases
     *   0x02 0N sizeLimit
     *   0x02 0N timeLimit
     *   0x01 0x01 typesOnly
     *   filter.encode()
     *   0x30 LL attributeDescriptionList
     *     0x04 LL attributeDescription
     *     ...
     *     0x04 LL attributeDescription
     * </pre>
     *
     * @param codec The LdapApiService instance
     * @param buffer The buffer where to put the PDU
     * @param message the ModifyRequest to encode
     */
    @Override
    public void encodeReverse( LdapApiService codec, Asn1Buffer buffer, Message message )
    {
        int start = buffer.getPos();
        SearchRequest searchRequest = ( SearchRequest ) message;

        // The attributes, if any
        List<String> attributes = searchRequest.getAttributes();

        if ( ( attributes != null ) && ( !attributes.isEmpty() ) )
        {
            for ( int i = attributes.size(); i > 0; i-- )
            {
                BerValue.encodeOctetString( buffer, attributes.get( i - 1 ) );
            }
        }

        // The attributes sequence
        BerValue.encodeSequence( buffer, start );

        // The filter
        encodeFilter( buffer, searchRequest.getFilter() );

        // The typesOnly
        BerValue.encodeBoolean( buffer, searchRequest.getTypesOnly() );

        // The timeLimit
        BerValue.encodeInteger( buffer, searchRequest.getTimeLimit() );

        // The sizeLimit
        BerValue.encodeInteger( buffer, searchRequest.getSizeLimit() );

        // The derefAliases
        BerValue.encodeEnumerated( buffer, searchRequest.getDerefAliases().getValue() );

        // The scope
        BerValue.encodeEnumerated( buffer, searchRequest.getScope().getScope() );

        // The base object
        BerValue.encodeOctetString( buffer, Strings.getBytesUtf8( searchRequest.getBase().getName() ) );

        // The SearchRequest tag
        BerValue.encodeSequence( buffer, LdapCodecConstants.SEARCH_REQUEST_TAG, start );
    }
}