*  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.

* 

*/

* This class is the base for every operations sent or received to and

* from a LDAP server.

*

* A connection instance is necessary to send requests to the server. The connection

* is valid until either the client closes it, the server closes it or the

* client does an unbind.

*

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

* @version $Rev$, $Date$

*/

    /** logger for reporting errors that might not be handled properly upstream */

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

    private static final String LDAP_RESPONSE = "LdapReponse";

    /** The timeout used for response we are waiting for */

    private long timeOut = LdapConnectionConfig.DEFAULT_TIMEOUT;

    /** configuration object for the connection */

    private LdapConnectionConfig config = new LdapConnectionConfig();

    /** The connector open with the remote server */

    private IoConnector connector;

    /** A flag set to true when we used a local connector */

    private boolean localConnector;

    /** The Ldap codec */

    private IoFilter ldapProtocolFilter = new ProtocolCodecFilter( new LdapProtocolCodecFactory() );

    /** 

     * The created session, created when we open a connection with

     * the Ldap server.

     */

    private IoSession ldapSession;

    /** A Message ID which is incremented for each operation */

    private AtomicInteger messageId;

    /** a map to hold the ResponseFutures for all operations */

    private Map<Integer, ResponseFuture<? extends Response>> futureMap = new ConcurrentHashMap<Integer, ResponseFuture<? extends Response>>();

    /** list of controls supported by the server */

    private List<String> supportedControls;

    /** The ROOT DSE entry */

    private Entry rootDSE;

   

    /** A flag indicating that the BindRequest has been issued and successfully authenticated the user */

    private AtomicBoolean authenticated = new AtomicBoolean( false );

   

    /** A flag indicating that the connection is connected or not */

    private AtomicBoolean connected = new AtomicBoolean( false );

   

    /** the schema manager */

    private SchemaManager schemaManager;

    // ~~~~~~~~~~~~~~~~~ common error messages ~~~~~~~~~~~~~~~~~~~~~~~~~~

    private static final String OPERATION_CANCELLED = "Operation would have been cancelled";

    static final String TIME_OUT_ERROR = "TimeOut occured";

    static final String NO_RESPONSE_ERROR = "The response queue has been emptied, no response was found.";

    private static final String COMPARE_FAILED = "Failed to perform compare operation";

    //--------------------------- Helper methods ---------------------------//

    /**

     * Check if we are connected

     *

     * @return <code>true</code> if we are connected.

     */

    public boolean isConnected()

    {

        return ( ldapSession != null ) && connected.get();

    }

    /**

     * Check if we are authenticated

     *

     * @return <code>true</code> if we are connected.

     */

    public boolean isAuthenticated()

    {

        return isConnected() && authenticated.get();

    }

    /**

     * Check that a session is valid, ie we can send requests to the

     * server

     *

     * @throws Exception If the session is not valid

     */

    private void checkSession() throws InvalidConnectionException

    {

        if ( ldapSession == null )

        {

            throw new InvalidConnectionException( "Cannot connect on the server, the connection is null" );

        }

        if ( !connected.get() )

        {

            throw new InvalidConnectionException( "Cannot connect on the server, the connection is invalid" );

        }

    }

   

   

    private void addToFutureMap( int messageId, ResponseFuture<? extends Response> future )

    {

        LOG.debug( "Adding <" + messageId + ", " + future.getClass().getName() + ">" );

        futureMap.put( messageId, future );

    }

   

   

    private ResponseFuture<? extends Response> getFromFutureMap( int messageId )

    {

        ResponseFuture<? extends Response> future = futureMap.remove( messageId );

       

        if ( future != null )

        {

            LOG.debug( "Removing <" + messageId + ", " + future.getClass().getName() + ">" );

        }

       

        return future;

    }

    private ResponseFuture<? extends Response> peekFromFutureMap( int messageId )

    {

        ResponseFuture<? extends Response> future = futureMap.get( messageId );

       

        // future can be null if there was a abandon operation on that messageId

        if( future != null )

        {

            LOG.debug( "Getting <" + messageId + ", " + future.getClass().getName() + ">" );

        }

       

        return future;

    }

    /**

     * Return the response stored into the current session.

     *

     * @return The last request response

     */

    public LdapMessageCodec getResponse()

    {

        return ( LdapMessageCodec ) ldapSession.getAttribute( LDAP_RESPONSE );

    }

    /**

     * Inject the client Controls into the message

     */

    private void setControls( Map<String, Control> controls, LdapMessageCodec message )

    {

        // Add the controls

        if ( controls != null )

        {

            for ( Control control : controls.values() )

            {

                ControlImpl ctrl = new ControlImpl( control.getOid() );

                ctrl.setValue( control.getValue() );

                message.addControl( ctrl );

            }

        }

    }

    /**

     * Get the smallest timeout from the client timeout and the connection

     * timeout.

     */

    private long getTimeout( long clientTimeOut )

    {

        if ( clientTimeOut <= 0 )

        {

            return ( timeOut <= 0 ) ? Long.MAX_VALUE : timeOut;

        }

        else if ( timeOut <= 0 )

        {

            return clientTimeOut;

        }

        else

        {

            return timeOut < clientTimeOut ? timeOut : clientTimeOut;

        }

    }

    /**

     * Convert a BindResponseCodec to a BindResponse message

     */

    private BindResponse convert( BindResponseCodec bindResponseCodec )

    {

        BindResponse bindResponse = new BindResponse();

        bindResponse.setMessageId( bindResponseCodec.getMessageId() );

        bindResponse.setServerSaslCreds( bindResponseCodec.getServerSaslCreds() );

        bindResponse.setLdapResult( convert( bindResponseCodec.getLdapResult() ) );

        return bindResponse;

    }

    /**

     * Convert a IntermediateResponseCodec to a IntermediateResponse message based on the ResponseFuture's type

     */

    private void setIResponse( IntermediateResponseCodec intermediateResponseCodec, ResponseFuture responseFuture ) throws Exception

    {

        IntermediateResponse intermediateResponse = null;

        if( responseFuture instanceof SearchFuture )

        {

            intermediateResponse = new SearchIntermediateResponse();

        }

        else if( responseFuture instanceof ExtendedFuture )

        {

            intermediateResponse = new ExtendedIntermediateResponse();

        }

        else

        {

            // currently we only support IR for search and extended operations

            throw new UnsupportedOperationException( "Unknown ResponseFuture type " + responseFuture.getClass().getName() );

        }

       

        intermediateResponse.setResponseName( intermediateResponseCodec.getResponseName() );

        intermediateResponse.setResponseValue( intermediateResponseCodec.getResponseValue() );

        responseFuture.set( intermediateResponse );

    }

    /**

     * Convert a LdapResultCodec to a LdapResult message

     */

    private LdapResult convert( LdapResultCodec ldapResultCodec )

    {

        LdapResult ldapResult = new LdapResult();

        ldapResult.setErrorMessage( ldapResultCodec.getErrorMessage() );

        ldapResult.setMatchedDn( ldapResultCodec.getMatchedDN() );

        // Loop on the referrals

        Referral referral = new Referral();

        if ( ldapResultCodec.getReferrals() != null )

        {

            for ( LdapURL url : ldapResultCodec.getReferrals() )

            {

                referral.addLdapUrls( url );

            }

        }

        ldapResult.setReferral( referral );

        ldapResult.setResultCode( ldapResultCodec.getResultCode() );

        return ldapResult;

    }

    /**

     * Convert a SearchResultEntryCodec to a SearchResultEntry message

     */

    private SearchResultEntry convert( SearchResultEntryCodec searchEntryResultCodec )